From bb1028f1919920a08008e87f22ff8221c2d8e7c4 Mon Sep 17 00:00:00 2001
From: RudraBJoshi <rudraj2022@gmail.com>
Date: Mon, 18 May 2026 11:24:23 -0700
Subject: [PATCH 1/6] New Robot Pseudocode

---
 _includes/runners/code.html                   |  34 +-
 .../2026-05-12-AP-CSP_Pseudocode_runner.ipynb | 192 ++++++++++-
 _sass/open-coding/forms/code-runner.scss      |   5 +
 .../PseudocodeExecutor.js                     |   2 +-
 .../Pseudosystem_Executors/RobotExecutor.js   | 313 ++++++++++++++++++
 assets/js/pages/runners/index.js              |   3 +-
 assets/js/pages/runners/tilemaps/index.js     | 275 +++++++++++++++
 7 files changed, 808 insertions(+), 16 deletions(-)
 rename assets/js/pages/runners/executors/{ => Pseudosystem_Executors}/PseudocodeExecutor.js (99%)
 create mode 100644 assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
 create mode 100644 assets/js/pages/runners/tilemaps/index.js

diff --git a/_includes/runners/code.html b/_includes/runners/code.html
index 8be07cf464..0244c2c056 100644
--- a/_includes/runners/code.html
+++ b/_includes/runners/code.html
@@ -60,9 +60,12 @@
 // AP CSP Pseudocode syntax highlighting mode for CodeMirror 5
 if (typeof CodeMirror !== 'undefined' && !CodeMirror.modes['pseudocode']) {
   CodeMirror.defineMode('pseudocode', function() {
-    const KW  = new Set(['IF','ELSE','REPEAT','TIMES','UNTIL','FOR','EACH','IN','PROCEDURE','RETURN','AND','OR','NOT','MOD']);
-    const BI  = new Set(['DISPLAY','INPUT','APPEND','INSERT','REMOVE','LENGTH']);
-    const BOOL= new Set(['TRUE','FALSE']);
+    const KW         = new Set(['IF','ELSE','REPEAT','TIMES','UNTIL','FOR','EACH','IN','PROCEDURE','RETURN','AND','OR','NOT','MOD']);
+    const BI         = new Set(['DISPLAY','INPUT','APPEND','INSERT','REMOVE','LENGTH']);
+    const BOOL       = new Set(['TRUE','FALSE']);
+    // Robot commands folded into existing token types for colour consistency
+    const BI_EXTRA = new Set(['MOVE_FORWARD','ROTATE_LEFT','ROTATE_RIGHT','CAN_MOVE','RENDER']);
+    const KW_EXTRA = new Set(['SPAWN','CHARACTER','GOAL','AT','FROM','TILEMAPS','IMPORT']);
     return {
       token: function(stream) {
         if (stream.eatSpace()) return null;
@@ -70,11 +73,11 @@
         // Comments
         if (stream.match('//')) { stream.skipToEnd(); return 'comment'; }
 
-        // Strings — handles curly and straight quotes
+        // Strings — handles curly (“ ”) and straight quotes
         const q = stream.peek();
-        if (q === '"' || q === '“' || q === '”' || q === "'") {
+        if (q === '"' || q === '\u201c' || q === '\u201d' || q === "'") {
           stream.next();
-          const close = (q === '“') ? '”' : q;
+          const close = (q === '\u201c') ? '\u201d' : q;
           while (!stream.eol() && stream.peek() !== close) stream.next();
           if (!stream.eol()) stream.next();
           return 'string';
@@ -83,12 +86,12 @@
         // Numbers
         if (stream.match(/^-?\d+(\.\d*)?/)) return 'number';
 
-        // Words: keywords / builtins / booleans / identifiers
+        // Words: robot commands take priority, then pseudocode keywords
         if (stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/)) {
           const w = stream.current().toUpperCase();
-          if (KW.has(w))   return 'keyword';
-          if (BI.has(w))   return 'builtin';
-          if (BOOL.has(w)) return 'atom';
+          if (KW.has(w) || KW_EXTRA.has(w)) return 'keyword';
+          if (BI.has(w) || BI_EXTRA.has(w)) return 'builtin';
+          if (BOOL.has(w))         return 'atom';
           return 'variable';
         }
 
@@ -108,7 +111,7 @@
 </script>
 
 <script type="module">
-import { BaseRunner, CodeExecutor, PseudocodeExecutor } from '{{site.baseurl}}/assets/js/pages/runners/index.js';
+import { BaseRunner, CodeExecutor, PseudocodeExecutor, RobotExecutor } from '{{site.baseurl}}/assets/js/pages/runners/index.js';
 import { pythonURI, javaURI, fetchOptions } from '{{site.baseurl}}/assets/js/api/config.js';
 
 (function() {
@@ -153,6 +156,11 @@
     execTimeElement: execTimeSpan,
   });
 
+  const robotExecutor = new RobotExecutor({
+    outputElement: outputDiv,
+    execTimeElement: execTimeSpan,
+  });
+
   // Set initial language selection
   if (initialLang) {
     langSelect.value = initialLang;
@@ -208,7 +216,9 @@
   // Run button logic
   function runCode() {
     if (langSelect.value === "pseudocode") {
-      return pseudoExecutor.run(editor.getValue());
+      const src = editor.getValue();
+      if (RobotExecutor.detect(src)) return robotExecutor.run(src);
+      return pseudoExecutor.run(src);
     }
     return codeExecutor.run();
   }
diff --git a/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb b/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
index b84f3b47a6..97bd125514 100644
--- a/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
+++ b/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
@@ -4,7 +4,19 @@
    "cell_type": "markdown",
    "id": "9d9630e1",
    "metadata": {},
-   "source": "---\nlayout: post\ntitle: AP CSP Pseudocode Runner\ndescription: A tool to run AP CSP Pseudocode.\nbreadcrumb: True\ncourses: { csp: {week: 30} }\ncomments: false\ntype: ccc\ncodemirror: true\npermalink: /csp/pseudocode-runner/\n---"
+   "source": [
+    "---\n",
+    "layout: post\n",
+    "title: AP CSP Pseudocode Runner\n",
+    "description: A tool to run AP CSP Pseudocode.\n",
+    "breadcrumb: True\n",
+    "courses: { csp: {week: 30} }\n",
+    "comments: false\n",
+    "type: ccc\n",
+    "codemirror: true\n",
+    "permalink: /csp/pseudocode-runner/\n",
+    "---"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -17,11 +29,187 @@
     "\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "f63ef927",
+   "metadata": {},
+   "source": [
+    "<details>\n",
+    "<summary><strong>Pseudocode Keyword Reference</strong> (click to expand)</summary>\n",
+    "\n",
+    "All keywords are **case-insensitive** — `if`, `IF`, and `If` all work. Type `<--` for `←`, `!=` for `≠`, `>=` for `≥`, `<=` for `≤`.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### Variables & Assignment\n",
+    "\n",
+    "Use `←` to assign a value. Variables are created on first assignment.\n",
+    "\n",
+    "```\n",
+    "x ← 5\n",
+    "name ← \"Alice\"\n",
+    "flag ← TRUE\n",
+    "```\n",
+    "\n",
+    "> Types: numbers, strings (`\"double quotes\"`), `TRUE` / `FALSE`\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### DISPLAY & INPUT\n",
+    "\n",
+    "| Command | What it does |\n",
+    "|---|---|\n",
+    "| `DISPLAY(value)` | Prints a value to the output box |\n",
+    "| `INPUT(\"prompt\")` | Prompts the user; auto-converts to number/boolean if possible |\n",
+    "\n",
+    "```\n",
+    "DISPLAY(\"Hello!\")\n",
+    "age ← INPUT(\"Enter your age: \")\n",
+    "DISPLAY(age)\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### Operators\n",
+    "\n",
+    "**Arithmetic:** `+` `-` `*` `/` `MOD`\n",
+    "> `+` also concatenates strings\n",
+    "\n",
+    "**Comparison:** `=` `≠` `<` `>` `≤` `≥`\n",
+    "\n",
+    "**Logical:** `AND` `OR` `NOT`\n",
+    "\n",
+    "```\n",
+    "DISPLAY(10 MOD 3)        // 1\n",
+    "DISPLAY(5 = 5)           // TRUE\n",
+    "DISPLAY(TRUE AND FALSE)  // FALSE\n",
+    "DISPLAY(NOT FALSE)       // TRUE\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### IF / ELSE\n",
+    "\n",
+    "```\n",
+    "IF (condition) {\n",
+    "    // runs if TRUE\n",
+    "} ELSE {\n",
+    "    // runs if FALSE  (ELSE block is optional)\n",
+    "}\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### Loops\n",
+    "\n",
+    "**REPEAT n TIMES**\n",
+    "```\n",
+    "REPEAT 5 TIMES {\n",
+    "    DISPLAY(\"hello\")\n",
+    "}\n",
+    "```\n",
+    "\n",
+    "**REPEAT UNTIL** — loops until condition is `TRUE`\n",
+    "```\n",
+    "x ← 0\n",
+    "REPEAT UNTIL (x = 5) {\n",
+    "    x ← x + 1\n",
+    "}\n",
+    "```\n",
+    "\n",
+    "**FOR EACH IN** — iterates over a list\n",
+    "```\n",
+    "FOR EACH n IN [1, 2, 3] {\n",
+    "    DISPLAY(n * 2)\n",
+    "}\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### Lists\n",
+    "\n",
+    "**1-based indexing** — first element is at index `1`.\n",
+    "\n",
+    "| Command | What it does |\n",
+    "|---|---|\n",
+    "| `list[i]` | Get element at index `i` |\n",
+    "| `list[i] ← value` | Set element at index `i` |\n",
+    "| `APPEND(list, value)` | Add to end |\n",
+    "| `INSERT(list, i, value)` | Insert at index `i` |\n",
+    "| `REMOVE(list, i)` | Remove at index `i` |\n",
+    "| `LENGTH(list)` | Number of elements |\n",
+    "\n",
+    "```\n",
+    "nums ← [10, 20, 30]\n",
+    "APPEND(nums, 40)\n",
+    "DISPLAY(LENGTH(nums))   // 4\n",
+    "DISPLAY(nums[1])        // 10\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### PROCEDURE & RETURN\n",
+    "\n",
+    "```\n",
+    "PROCEDURE add(a, b) {\n",
+    "    RETURN a + b\n",
+    "}\n",
+    "DISPLAY(add(3, 4))   // 7\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n",
+    "#### Robot / Grid Commands\n",
+    "\n",
+    "These activate the visual 7×7 grid. Write setup lines first, then movement logic.\n",
+    "\n",
+    "**Setup** (stripped before execution)\n",
+    "\n",
+    "| Command | What it does |\n",
+    "|---|---|\n",
+    "| `from tilemaps import N` | Load preset map `N` (1–25) |\n",
+    "| `spawn character at (col, row)` | Place robot at col, row (1-based), facing up |\n",
+    "| `spawn goal at (col, row)` | Place a goal star |\n",
+    "\n",
+    "**Movement** (called at runtime)\n",
+    "\n",
+    "| Command | What it does |\n",
+    "|---|---|\n",
+    "| `MOVE_FORWARD()` | Move one cell forward |\n",
+    "| `ROTATE_LEFT()` | Turn 90° counter-clockwise |\n",
+    "| `ROTATE_RIGHT()` | Turn 90° clockwise |\n",
+    "| `CAN_MOVE(\"direction\")` | `TRUE` if passable — `\"forward\"` `\"backward\"` `\"left\"` `\"right\"` |\n",
+    "| `RENDER(matrix)` | Load a custom 7×7 list-of-lists as the grid (0=open, 1=wall) |\n",
+    "\n",
+    "```\n",
+    "from tilemaps import 12\n",
+    "spawn character at (1,1)\n",
+    "spawn goal at (7,7)\n",
+    "\n",
+    "REPEAT UNTIL (CAN_MOVE(\"forward\") = FALSE) {\n",
+    "    MOVE_FORWARD()\n",
+    "}\n",
+    "ROTATE_RIGHT()\n",
+    "MOVE_FORWARD()\n",
+    "```\n",
+    "\n",
+    "</details>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "513a92fa",
+   "metadata": {},
+   "source": "<details>\n<summary><strong>Tilemap Directory</strong> — IDs 1–25 (click to expand)</summary>\n\nUse these IDs with `from tilemaps import N`. All maps are 7×7, 0 = open, 1 = wall.\n\n| ID | Name | Description |\n|---|---|---|\n| 1 | Scattered walls | Open grid with a few wall clusters — good starter map |\n| 2 | Column gaps | Vertical wall pairs with clear corridors between them |\n| 3 | Double gate | Two horizontal barriers each with a single opening in the centre |\n| 4 | Staggered columns | Alternating column walls; open row in the middle connects them |\n| 5 | Ring | Solid 5×5 wall ring with an open interior and outer path |\n| 6 | Diamond obstacles | Symmetric diagonal obstacles around a centre wall |\n| 7 | Cross barrier | Plus-sign wall with a single gap on each axis |\n| 8 | Dot grid | Regular 2×2 wall dots across the grid — many equal paths |\n| 9 | S-curve | Single-width path: left → down → right → down |\n| 10 | T-junction | Open top row splits into two shafts that merge to a single exit |\n| 11 | Two rooms | Wall divides the grid; one corridor connects the rooms at row 4 |\n| 12 | Zigzag slalom | Barriers alternate sides — forces full end-to-end traversal |\n| 13 | Diagonal obstacles | Diagonal line of single-cell walls; open space on both sides |\n| 14 | Slalom barriers | Two staggered barriers each with one opening — weave through |\n| 15 | Winding river | Narrow single-width path snaking from top-left to bottom-right |\n| 16 | Cross open | Plus-sign open area in the centre; corners are walled off |\n| 17 | Perimeter loop | Outer ring is fully open; solid 5×5 block in the interior |\n| 18 | Grid maze | Open intersections with wall segments — multiple valid routes |\n| 19 | Columns | Tall wall columns with one open row in the middle |\n| 20 | Honeycomb | Staggered single-cell obstacles; lots of routing options |\n| 21 | Staircase | 2-wide diagonal path from top-left to bottom-right |\n| 22 | Scattered obstacles | Mostly open with light random single-cell walls |\n| 23 | L-corridor | Left column + bottom row form an L-shaped path |\n| 24 | Double loop | Four 2×2 wall blocks leave open rings and a centre cross |\n| 25 | Funnel | Wide open top narrows to a single-column corridor at the bottom |\n\n</details>"
+  },
   {
    "cell_type": "markdown",
    "id": "16a6ead3",
    "metadata": {},
-   "source": "{% capture csp_default %}DISPLAY(\"HELLO WORLD!\"){% endcapture %}\n{% include runners/code.html runner_id=\"pseudocode-main\" language=\"pseudocode\" code=csp_default %}"
+   "source": [
+    "{% capture csp_default %}DISPLAY(\"HELLO WORLD!\"){% endcapture %}\n",
+    "{% include runners/code.html runner_id=\"pseudocode-main\" language=\"pseudocode\" code=csp_default %}"
+   ]
   }
  ],
  "metadata": {
diff --git a/_sass/open-coding/forms/code-runner.scss b/_sass/open-coding/forms/code-runner.scss
index 4f78af4517..cb913c7f0d 100644
--- a/_sass/open-coding/forms/code-runner.scss
+++ b/_sass/open-coding/forms/code-runner.scss
@@ -23,4 +23,9 @@
   .copyOutputBtn {
     @include icon-button(38px, 0);
   }
+
+  // Override Darcula's green comment colour with gray
+  .cm-comment {
+    color: #7f849c !important;
+  }
 }
diff --git a/assets/js/pages/runners/executors/PseudocodeExecutor.js b/assets/js/pages/runners/executors/Pseudosystem_Executors/PseudocodeExecutor.js
similarity index 99%
rename from assets/js/pages/runners/executors/PseudocodeExecutor.js
rename to assets/js/pages/runners/executors/Pseudosystem_Executors/PseudocodeExecutor.js
index e0be2c3b1d..610a40cace 100644
--- a/assets/js/pages/runners/executors/PseudocodeExecutor.js
+++ b/assets/js/pages/runners/executors/Pseudosystem_Executors/PseudocodeExecutor.js
@@ -250,7 +250,7 @@ function gen(ast) {
   return stmts(ast);
 }
 
-function compile(src) {
+export function compile(src) {
   return gen(new Parser(tokenize(src)).parse());
 }
 
diff --git a/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js b/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
new file mode 100644
index 0000000000..9a05a4e628
--- /dev/null
+++ b/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
@@ -0,0 +1,313 @@
+import { getTilemap } from '../../tilemaps/index.js';
+import { compile } from './PseudocodeExecutor.js';
+
+// Canvas dimensions
+const CELL = 64;
+const PAD  = 16;
+const GRID = 7;
+const SIZE = CELL * GRID + PAD * 2;
+
+const EMPTY_GRID = Array.from({ length: GRID }, () => Array(GRID).fill(0));
+
+// Direction vectors: 0=up, 1=right, 2=down, 3=left
+const DIR_DELTA = [
+  { dr: -1, dc:  0 },
+  { dr:  0, dc:  1 },
+  { dr:  1, dc:  0 },
+  { dr:  0, dc: -1 },
+];
+const DIR_NAMES = ['up', 'right', 'down', 'left'];
+
+function cloneGrid(g) { return g.map(r => [...r]); }
+
+function parseSource(src) {
+  let tilemapId = null;
+  let spawnCol = null, spawnRow = null;
+  let goalCol  = null, goalRow  = null;
+  const codeLines = [];
+
+  for (const raw of src.split('\n')) {
+    const line = raw.trim();
+
+    const mMap = line.match(/^from\s+tilemaps\s+import\s+(\d+)$/i);
+    if (mMap) { tilemapId = parseInt(mMap[1], 10); continue; }
+
+    const mSpawn = line.match(/^spawn\s+character\s+at\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)$/i);
+    if (mSpawn) { spawnCol = parseInt(mSpawn[1], 10) - 1; spawnRow = parseInt(mSpawn[2], 10) - 1; continue; }
+
+    const mGoal = line.match(/^spawn\s+goal\s+at\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)$/i);
+    if (mGoal) { goalCol = parseInt(mGoal[1], 10) - 1; goalRow = parseInt(mGoal[2], 10) - 1; continue; }
+
+    codeLines.push(raw);
+  }
+
+  return { tilemapId, spawnCol, spawnRow, goalCol, goalRow, pseudoSrc: codeLines.join('\n') };
+}
+
+function simulate(pseudoSrc, initialGrid, startCol, startRow) {
+  let col = startCol, row = startRow, dir = 0;
+  let grid = cloneGrid(initialGrid);
+
+  // Each frame snapshots the grid so RENDER changes are reflected correctly during animation
+  const frames = [{ col, row, dir, error: null, grid: cloneGrid(grid) }];
+  let steps = 0;
+
+  const RENDER = (matrix) => {
+    if (!Array.isArray(matrix) || matrix.length !== GRID)
+      throw new Error(`AP CSP Robot Error: RENDER requires a ${GRID}×${GRID} matrix (got ${Array.isArray(matrix) ? matrix.length : typeof matrix} rows)`);
+    for (let ri = 0; ri < matrix.length; ri++) {
+      const r = matrix[ri];
+      if (!Array.isArray(r) || r.length !== GRID)
+        throw new Error(`AP CSP Robot Error: RENDER row ${ri + 1} must have ${GRID} cells`);
+    }
+    grid = cloneGrid(matrix);
+    frames.push({ col, row, dir, error: null, grid: cloneGrid(grid) });
+  };
+
+  const MOVE_FORWARD = () => {
+    const { dr, dc } = DIR_DELTA[dir];
+    const nr = row + dr, nc = col + dc;
+    if (nr < 0 || nr >= GRID || nc < 0 || nc >= GRID || grid[nr][nc] === 1)
+      throw new Error('AP CSP Robot Error: MOVE_FORWARD into a wall or boundary');
+    row = nr; col = nc;
+    frames.push({ col, row, dir, error: null, grid: cloneGrid(grid) });
+  };
+
+  const ROTATE_LEFT = () => {
+    dir = (dir + 3) % 4;
+    frames.push({ col, row, dir, error: null, grid: cloneGrid(grid) });
+  };
+
+  const ROTATE_RIGHT = () => {
+    dir = (dir + 1) % 4;
+    frames.push({ col, row, dir, error: null, grid: cloneGrid(grid) });
+  };
+
+  const CAN_MOVE = (dirName) => {
+    const d = DIR_NAMES.indexOf(String(dirName).toLowerCase());
+    if (d === -1) throw new Error(`AP CSP Robot Error: CAN_MOVE got unknown direction "${dirName}"`);
+    const { dr, dc } = DIR_DELTA[d];
+    const nr = row + dr, nc = col + dc;
+    return !(nr < 0 || nr >= GRID || nc < 0 || nc >= GRID || grid[nr][nc] === 1);
+  };
+
+  const __out  = () => {};
+  const __inp  = () => '';
+  const __step = () => {
+    if (++steps > 10000) throw new Error('AP CSP Robot Error: Possible infinite loop (exceeded 10k steps)');
+  };
+  const __add = (a, b) => (typeof a === 'number' && typeof b === 'number') ? a + b : String(a) + String(b);
+  const __cmp = (a, op, b) => {
+    if (op === '=') return a === b;
+    if (op === '≠') return a !== b;
+    if (typeof a !== 'number' || typeof b !== 'number')
+      throw new Error('AP CSP Runtime Error: Cannot use "' + op + '" to compare non-numeric values');
+    if (op === '>') return a > b;
+    if (op === '<') return a < b;
+    if (op === '≥') return a >= b;
+    return a <= b;
+  };
+
+  const code = compile(pseudoSrc.trim());
+  try {
+    new Function(
+      '__out','__inp','__step','__add','__cmp',
+      'MOVE_FORWARD','ROTATE_LEFT','ROTATE_RIGHT','CAN_MOVE','RENDER',
+      code
+    )(__out, __inp, __step, __add, __cmp, MOVE_FORWARD, ROTATE_LEFT, ROTATE_RIGHT, CAN_MOVE, RENDER);
+  } catch(e) {
+    frames.push({ col, row, dir, error: e.message, grid: cloneGrid(grid) });
+  }
+
+  return frames;
+}
+
+// grid is now read from frame.grid instead of passed separately
+function drawFrame(ctx, frame, goal = null) {
+  const grid = frame.grid;
+  ctx.clearRect(0, 0, SIZE, SIZE);
+
+  ctx.fillStyle = '#1e1e2e';
+  ctx.fillRect(0, 0, SIZE, SIZE);
+
+  for (let r = 0; r < GRID; r++) {
+    for (let c = 0; c < GRID; c++) {
+      const x = PAD + c * CELL;
+      const y = PAD + r * CELL;
+      ctx.fillStyle = grid[r][c] === 1 ? '#45475a' : '#313244';
+      ctx.fillRect(x + 2, y + 2, CELL - 4, CELL - 4);
+
+      if (grid[r][c] === 1) {
+        ctx.fillStyle = '#585b70';
+        ctx.fillRect(x + 6, y + 6, CELL - 12, CELL - 12);
+      }
+
+      ctx.strokeStyle = '#6c7086';
+      ctx.lineWidth = 1;
+      ctx.strokeRect(x + 2, y + 2, CELL - 4, CELL - 4);
+    }
+  }
+
+  // Goal
+  if (goal) {
+    const reached = frame.col === goal.col && frame.row === goal.row;
+    const gx = PAD + goal.col * CELL + CELL / 2;
+    const gy = PAD + goal.row * CELL + CELL / 2;
+    const gr = CELL * 0.28;
+
+    ctx.save();
+    ctx.beginPath();
+    ctx.arc(gx, gy, gr + 4, 0, Math.PI * 2);
+    ctx.strokeStyle = reached ? '#a6e3a1' : '#f9e2af44';
+    ctx.lineWidth = 3;
+    ctx.stroke();
+
+    ctx.beginPath();
+    const spikes = 5, outerR = gr, innerR = gr * 0.45;
+    for (let s = 0; s < spikes * 2; s++) {
+      const angle = (s * Math.PI) / spikes - Math.PI / 2;
+      const rad   = s % 2 === 0 ? outerR : innerR;
+      const sx    = gx + Math.cos(angle) * rad;
+      const sy    = gy + Math.sin(angle) * rad;
+      s === 0 ? ctx.moveTo(sx, sy) : ctx.lineTo(sx, sy);
+    }
+    ctx.closePath();
+    ctx.fillStyle = reached ? '#a6e3a1' : '#f9e2af';
+    ctx.fill();
+    ctx.restore();
+  }
+
+  // Robot
+  const rx = PAD + frame.col * CELL + CELL / 2;
+  const ry = PAD + frame.row * CELL + CELL / 2;
+  const r  = CELL * 0.32;
+
+  ctx.save();
+  ctx.translate(rx, ry);
+  ctx.rotate((frame.dir - 1) * Math.PI / 2);
+
+  ctx.beginPath();
+  ctx.arc(0, 0, r, 0, Math.PI * 2);
+  ctx.fillStyle = frame.error ? '#f38ba8' : '#89b4fa';
+  ctx.fill();
+  ctx.strokeStyle = frame.error ? '#eba0ac' : '#b4befe';
+  ctx.lineWidth = 2.5;
+  ctx.stroke();
+
+  ctx.beginPath();
+  ctx.moveTo(-r * 0.35, 0);
+  ctx.lineTo( r * 0.45, 0);
+  ctx.strokeStyle = '#1e1e2e';
+  ctx.lineWidth = 3.5;
+  ctx.lineCap = 'round';
+  ctx.stroke();
+
+  ctx.beginPath();
+  ctx.moveTo(r * 0.18, -r * 0.3);
+  ctx.lineTo(r * 0.48,  0);
+  ctx.lineTo(r * 0.18,  r * 0.3);
+  ctx.fillStyle = '#1e1e2e';
+  ctx.fill();
+
+  ctx.restore();
+}
+
+function animate(canvas, frames, goal, outputDiv, execTimeSpan, startMs) {
+  const ctx = canvas.getContext('2d');
+  const DELAY = 320;
+  let i = 0;
+
+  function step() {
+    drawFrame(ctx, frames[i], goal);
+
+    const last = frames[frames.length - 1];
+    if (i === frames.length - 1) {
+      if (execTimeSpan)
+        execTimeSpan.textContent = last.error
+          ? ''
+          : `⏱ ${frames.length - 1} move(s) · ${Date.now() - startMs}ms`;
+      if (last.error) {
+        const err = document.createElement('div');
+        err.style.cssText = 'color:#f38ba8;margin-top:6px;font-size:0.85em;';
+        err.textContent = last.error;
+        outputDiv.appendChild(err);
+      }
+      return;
+    }
+    i++;
+    setTimeout(step, DELAY);
+  }
+
+  step();
+}
+
+export class RobotExecutor {
+  constructor({ outputElement, execTimeElement } = {}) {
+    this.outputElement   = outputElement;
+    this.execTimeElement = execTimeElement;
+  }
+
+  static detect(src) {
+    return /^\s*from\s+tilemaps\s+import\s+\d+/im.test(src) ||
+           /^\s*spawn\s+character\s+at/im.test(src)         ||
+           /^\s*spawn\s+goal\s+at/im.test(src)              ||
+           /\bRENDER\s*\(/i.test(src);
+  }
+
+  run(src) {
+    const outputDiv    = this.outputElement;
+    const execTimeSpan = this.execTimeElement;
+    if (!outputDiv) return;
+
+    outputDiv.innerHTML = '';
+    if (execTimeSpan) execTimeSpan.textContent = '';
+
+    let parsed;
+    try { parsed = parseSource(src); }
+    catch(e) { outputDiv.textContent = e.message; return; }
+
+    const { tilemapId, spawnCol, spawnRow, goalCol, goalRow, pseudoSrc } = parsed;
+
+    if (spawnCol === null) {
+      outputDiv.textContent = 'Robot Error: missing "spawn character at (col, row)"';
+      return;
+    }
+
+    // Load preset tilemap or start blank — RENDER() in pseudocode can override at runtime
+    let initialGrid;
+    if (tilemapId !== null) {
+      try { initialGrid = getTilemap(tilemapId); }
+      catch(e) { outputDiv.textContent = e.message; return; }
+    } else {
+      initialGrid = cloneGrid(EMPTY_GRID);
+    }
+
+    if (initialGrid[spawnRow]?.[spawnCol] === 1) {
+      outputDiv.textContent = 'Robot Error: spawn position is inside a wall';
+      return;
+    }
+    if (goalCol !== null && initialGrid[goalRow]?.[goalCol] === 1) {
+      outputDiv.textContent = 'Robot Error: goal position is inside a wall';
+      return;
+    }
+
+    const goal = goalCol !== null ? { col: goalCol, row: goalRow } : null;
+
+    let frames;
+    try { frames = simulate(pseudoSrc, initialGrid, spawnCol, spawnRow); }
+    catch(e) { outputDiv.textContent = e.message; return; }
+
+    outputDiv.style.maxHeight = 'none';
+    outputDiv.style.overflowY = 'visible';
+
+    const canvas = document.createElement('canvas');
+    canvas.width  = SIZE;
+    canvas.height = SIZE;
+    canvas.style.cssText = 'display:block;max-width:100%;border-radius:8px;';
+    outputDiv.appendChild(canvas);
+
+    animate(canvas, frames, goal, outputDiv, execTimeSpan, Date.now());
+  }
+}
+
+export default RobotExecutor;
diff --git a/assets/js/pages/runners/index.js b/assets/js/pages/runners/index.js
index fa8d0f4516..444ed08af9 100644
--- a/assets/js/pages/runners/index.js
+++ b/assets/js/pages/runners/index.js
@@ -5,6 +5,7 @@ export { StorageManager } from './core/StorageManager.js';
 export { StatsManager } from './core/StatsManager.js';
 export { ButtonFeedback } from './core/ButtonFeedback.js';
 export { CodeExecutor } from './executors/CodeExecutor.js';
-export { PseudocodeExecutor } from './executors/PseudocodeExecutor.js';
+export { PseudocodeExecutor } from './executors/Pseudosystem_Executors/PseudocodeExecutor.js';
+export { RobotExecutor } from './executors/Pseudosystem_Executors/RobotExecutor.js';
 export { UiExecutor } from './executors/UiExecutor.js';
 export { GameExecutor } from './executors/GameExecutor.js';
diff --git a/assets/js/pages/runners/tilemaps/index.js b/assets/js/pages/runners/tilemaps/index.js
new file mode 100644
index 0000000000..d8c9bd33b6
--- /dev/null
+++ b/assets/js/pages/runners/tilemaps/index.js
@@ -0,0 +1,275 @@
+// 7x7 tilemaps: 0 = open, 1 = wall
+// Row 0 is the TOP of the grid, row 6 is the BOTTOM
+// All maps are verified to have at least one navigable path through them.
+export const tilemaps = {
+
+  // --- originals ---
+
+  1: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 1, 0, 0, 1, 0],
+    [0, 0, 1, 0, 0, 0, 0],
+    [0, 0, 0, 0, 1, 0, 0],
+    [0, 1, 0, 0, 1, 0, 0],
+    [0, 1, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+  2: [
+    [0, 0, 1, 0, 0, 1, 0],
+    [0, 0, 1, 0, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 1, 0, 1, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 0, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+  3: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 1, 0, 1, 1, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 1, 0, 1, 1, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+  4: [
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 0, 1, 0, 1, 0, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+  ],
+  5: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 1, 1, 1, 1, 0],
+    [0, 1, 0, 0, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 0, 0, 1, 0],
+    [0, 1, 1, 1, 1, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+  6: [
+    [1, 0, 0, 0, 0, 0, 1],
+    [0, 0, 1, 0, 1, 0, 0],
+    [0, 1, 0, 0, 0, 1, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 1, 0, 0, 0, 1, 0],
+    [0, 0, 1, 0, 1, 0, 0],
+    [1, 0, 0, 0, 0, 0, 1],
+  ],
+  7: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 1, 1, 1, 0, 0],
+    [1, 1, 1, 0, 1, 1, 1],
+    [0, 0, 1, 1, 1, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+  8: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // --- generated navigable mazes ---
+
+  // 9: S-curve — single-width path winds left→down→right→down
+  9: [
+    [0, 0, 0, 1, 1, 1, 1],
+    [1, 1, 0, 1, 1, 1, 1],
+    [1, 1, 0, 1, 1, 1, 1],
+    [1, 1, 0, 1, 1, 1, 1],
+    [1, 1, 0, 0, 0, 0, 0],
+    [1, 1, 1, 1, 1, 1, 0],
+    [1, 1, 1, 1, 1, 1, 0],
+  ],
+
+  // 10: T-junction — open row at top, two vertical shafts, meeting row mid, single exit down
+  10: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 0, 1, 1, 1, 0, 1],
+    [1, 0, 1, 1, 1, 0, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 1, 0, 1, 1, 1],
+    [1, 1, 1, 0, 1, 1, 1],
+    [1, 1, 1, 0, 1, 1, 1],
+  ],
+
+  // 11: Two rooms — divided by wall, single corridor connecting them at row 3
+  11: [
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+  ],
+
+  // 12: Zigzag slalom — barriers alternate left-blocked and right-blocked
+  12: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 1, 1, 1, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 1, 1, 1, 1, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 1, 1, 1, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // 13: Diagonal obstacles — diagonal wall line, open space on both sides
+  13: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 0, 0, 0, 0],
+    [0, 0, 1, 0, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 0, 1, 0, 0],
+    [0, 0, 0, 0, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // 14: Slalom barriers — two staggered walls force weaving
+  14: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 1, 1, 1, 0, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 0, 1, 1, 1, 1, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // 15: Winding river — single-width path snaking corner to corner
+  15: [
+    [0, 0, 0, 1, 1, 1, 1],
+    [1, 1, 0, 1, 1, 1, 1],
+    [1, 1, 0, 0, 0, 1, 1],
+    [1, 1, 1, 1, 0, 1, 1],
+    [1, 1, 1, 1, 0, 0, 0],
+    [1, 1, 1, 1, 1, 1, 0],
+    [1, 1, 1, 1, 1, 1, 0],
+  ],
+
+  // 16: Cross — plus-sign open area in the middle
+  16: [
+    [1, 1, 0, 0, 0, 1, 1],
+    [1, 1, 0, 0, 0, 1, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 0, 0, 0, 1, 1],
+    [1, 1, 0, 0, 0, 1, 1],
+  ],
+
+  // 17: Perimeter loop — outer ring is open, inside is solid wall
+  17: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 1, 1, 1, 1, 0],
+    [0, 1, 1, 1, 1, 1, 0],
+    [0, 1, 1, 1, 1, 1, 0],
+    [0, 1, 1, 1, 1, 1, 0],
+    [0, 1, 1, 1, 1, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // 18: Grid maze — open intersections, wall segments between
+  18: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 0, 1, 0, 1, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // 19: Columns — tall wall columns with row-wide gap in the middle
+  19: [
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+  ],
+
+  // 20: Honeycomb — staggered single-cell obstacles, fully open between
+  20: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 1, 0, 1, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 1, 0, 1, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // 21: Staircase — 2-wide diagonal path from top-left to bottom-right
+  21: [
+    [0, 0, 1, 1, 1, 1, 1],
+    [0, 0, 0, 1, 1, 1, 1],
+    [1, 0, 0, 0, 1, 1, 1],
+    [1, 1, 0, 0, 0, 1, 1],
+    [1, 1, 1, 0, 0, 0, 1],
+    [1, 1, 1, 1, 0, 0, 0],
+    [1, 1, 1, 1, 1, 0, 0],
+  ],
+
+  // 22: Scattered obstacles — mostly open with random single-cell walls
+  22: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 1, 0, 0, 0, 0],
+    [0, 0, 0, 0, 1, 0, 0],
+    [0, 1, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 1, 0, 1],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // 23: L-corridor — left column + bottom row form an L-shaped path
+  23: [
+    [0, 1, 1, 1, 1, 1, 1],
+    [0, 1, 1, 1, 1, 1, 1],
+    [0, 1, 1, 1, 1, 1, 1],
+    [0, 1, 1, 1, 1, 1, 1],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 1, 1, 1, 1, 0],
+    [1, 1, 1, 1, 1, 1, 0],
+  ],
+
+  // 24: Double loop — four 2x2 wall blocks leave open rings and a center cross
+  24: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 1, 0, 1, 1, 0],
+    [0, 1, 1, 0, 1, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 1, 1, 0, 1, 1, 0],
+    [0, 1, 1, 0, 1, 1, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+  ],
+
+  // 25: Funnel — wide top, funnels to single-cell corridor at the bottom
+  25: [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0],
+    [1, 0, 0, 0, 0, 0, 1],
+    [1, 1, 0, 0, 0, 1, 1],
+    [1, 1, 1, 0, 1, 1, 1],
+    [1, 1, 1, 0, 1, 1, 1],
+    [1, 1, 1, 0, 1, 1, 1],
+  ],
+};
+
+export function getTilemap(id) {
+  const map = tilemaps[id];
+  if (!map) throw new Error(`Tilemap ${id} not found`);
+  return map.map(row => [...row]);
+}

From 5acdd349b8bcfaf5b212e06eef7dc177d5c38560 Mon Sep 17 00:00:00 2001
From: RudraBJoshi <rudraj2022@gmail.com>
Date: Mon, 18 May 2026 11:25:53 -0700
Subject: [PATCH 2/6] Better Dir

---
 .../2026-05-12-AP-CSP_Pseudocode_runner.ipynb | 163 +-----------------
 1 file changed, 1 insertion(+), 162 deletions(-)

diff --git a/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb b/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
index 97bd125514..460b9e57c7 100644
--- a/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
+++ b/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
@@ -33,168 +33,7 @@
    "cell_type": "markdown",
    "id": "f63ef927",
    "metadata": {},
-   "source": [
-    "<details>\n",
-    "<summary><strong>Pseudocode Keyword Reference</strong> (click to expand)</summary>\n",
-    "\n",
-    "All keywords are **case-insensitive** — `if`, `IF`, and `If` all work. Type `<--` for `←`, `!=` for `≠`, `>=` for `≥`, `<=` for `≤`.\n",
-    "\n",
-    "---\n",
-    "\n",
-    "#### Variables & Assignment\n",
-    "\n",
-    "Use `←` to assign a value. Variables are created on first assignment.\n",
-    "\n",
-    "```\n",
-    "x ← 5\n",
-    "name ← \"Alice\"\n",
-    "flag ← TRUE\n",
-    "```\n",
-    "\n",
-    "> Types: numbers, strings (`\"double quotes\"`), `TRUE` / `FALSE`\n",
-    "\n",
-    "---\n",
-    "\n",
-    "#### DISPLAY & INPUT\n",
-    "\n",
-    "| Command | What it does |\n",
-    "|---|---|\n",
-    "| `DISPLAY(value)` | Prints a value to the output box |\n",
-    "| `INPUT(\"prompt\")` | Prompts the user; auto-converts to number/boolean if possible |\n",
-    "\n",
-    "```\n",
-    "DISPLAY(\"Hello!\")\n",
-    "age ← INPUT(\"Enter your age: \")\n",
-    "DISPLAY(age)\n",
-    "```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "#### Operators\n",
-    "\n",
-    "**Arithmetic:** `+` `-` `*` `/` `MOD`\n",
-    "> `+` also concatenates strings\n",
-    "\n",
-    "**Comparison:** `=` `≠` `<` `>` `≤` `≥`\n",
-    "\n",
-    "**Logical:** `AND` `OR` `NOT`\n",
-    "\n",
-    "```\n",
-    "DISPLAY(10 MOD 3)        // 1\n",
-    "DISPLAY(5 = 5)           // TRUE\n",
-    "DISPLAY(TRUE AND FALSE)  // FALSE\n",
-    "DISPLAY(NOT FALSE)       // TRUE\n",
-    "```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "#### IF / ELSE\n",
-    "\n",
-    "```\n",
-    "IF (condition) {\n",
-    "    // runs if TRUE\n",
-    "} ELSE {\n",
-    "    // runs if FALSE  (ELSE block is optional)\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "#### Loops\n",
-    "\n",
-    "**REPEAT n TIMES**\n",
-    "```\n",
-    "REPEAT 5 TIMES {\n",
-    "    DISPLAY(\"hello\")\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "**REPEAT UNTIL** — loops until condition is `TRUE`\n",
-    "```\n",
-    "x ← 0\n",
-    "REPEAT UNTIL (x = 5) {\n",
-    "    x ← x + 1\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "**FOR EACH IN** — iterates over a list\n",
-    "```\n",
-    "FOR EACH n IN [1, 2, 3] {\n",
-    "    DISPLAY(n * 2)\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "#### Lists\n",
-    "\n",
-    "**1-based indexing** — first element is at index `1`.\n",
-    "\n",
-    "| Command | What it does |\n",
-    "|---|---|\n",
-    "| `list[i]` | Get element at index `i` |\n",
-    "| `list[i] ← value` | Set element at index `i` |\n",
-    "| `APPEND(list, value)` | Add to end |\n",
-    "| `INSERT(list, i, value)` | Insert at index `i` |\n",
-    "| `REMOVE(list, i)` | Remove at index `i` |\n",
-    "| `LENGTH(list)` | Number of elements |\n",
-    "\n",
-    "```\n",
-    "nums ← [10, 20, 30]\n",
-    "APPEND(nums, 40)\n",
-    "DISPLAY(LENGTH(nums))   // 4\n",
-    "DISPLAY(nums[1])        // 10\n",
-    "```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "#### PROCEDURE & RETURN\n",
-    "\n",
-    "```\n",
-    "PROCEDURE add(a, b) {\n",
-    "    RETURN a + b\n",
-    "}\n",
-    "DISPLAY(add(3, 4))   // 7\n",
-    "```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "#### Robot / Grid Commands\n",
-    "\n",
-    "These activate the visual 7×7 grid. Write setup lines first, then movement logic.\n",
-    "\n",
-    "**Setup** (stripped before execution)\n",
-    "\n",
-    "| Command | What it does |\n",
-    "|---|---|\n",
-    "| `from tilemaps import N` | Load preset map `N` (1–25) |\n",
-    "| `spawn character at (col, row)` | Place robot at col, row (1-based), facing up |\n",
-    "| `spawn goal at (col, row)` | Place a goal star |\n",
-    "\n",
-    "**Movement** (called at runtime)\n",
-    "\n",
-    "| Command | What it does |\n",
-    "|---|---|\n",
-    "| `MOVE_FORWARD()` | Move one cell forward |\n",
-    "| `ROTATE_LEFT()` | Turn 90° counter-clockwise |\n",
-    "| `ROTATE_RIGHT()` | Turn 90° clockwise |\n",
-    "| `CAN_MOVE(\"direction\")` | `TRUE` if passable — `\"forward\"` `\"backward\"` `\"left\"` `\"right\"` |\n",
-    "| `RENDER(matrix)` | Load a custom 7×7 list-of-lists as the grid (0=open, 1=wall) |\n",
-    "\n",
-    "```\n",
-    "from tilemaps import 12\n",
-    "spawn character at (1,1)\n",
-    "spawn goal at (7,7)\n",
-    "\n",
-    "REPEAT UNTIL (CAN_MOVE(\"forward\") = FALSE) {\n",
-    "    MOVE_FORWARD()\n",
-    "}\n",
-    "ROTATE_RIGHT()\n",
-    "MOVE_FORWARD()\n",
-    "```\n",
-    "\n",
-    "</details>"
-   ]
+   "source": "<details>\n<summary><strong>Pseudocode Keyword Reference</strong> (click to expand)</summary>\n\nAll keywords are **case-insensitive**. Type `<--` for `←`, `!=` for `≠`, `>=` for `≥`, `<=` for `≤`.\n\n<details>\n<summary><strong>Variables &amp; Assignment</strong></summary>\n\nUse `←` to assign a value. Variables are created on first assignment.\n\n```\nx ← 5\nname ← \"Alice\"\nflag ← TRUE\n```\n\n> Types: numbers, strings (`\"double quotes\"`), `TRUE` / `FALSE`\n\n</details>\n\n<details>\n<summary><strong>DISPLAY &amp; INPUT</strong></summary>\n\n| Command | What it does |\n|---|---|\n| `DISPLAY(value)` | Prints a value to the output box |\n| `INPUT(\"prompt\")` | Prompts the user; auto-converts to number/boolean if possible |\n\n```\nDISPLAY(\"Hello!\")\nage ← INPUT(\"Enter your age: \")\nDISPLAY(age)\n```\n\n</details>\n\n<details>\n<summary><strong>Operators</strong></summary>\n\n**Arithmetic:** `+` `-` `*` `/` `MOD`\n> `+` also concatenates strings\n\n**Comparison:** `=` `≠` `<` `>` `≤` `≥`\n\n**Logical:** `AND` `OR` `NOT`\n\n```\nDISPLAY(10 MOD 3)        // 1\nDISPLAY(5 = 5)           // TRUE\nDISPLAY(TRUE AND FALSE)  // FALSE\nDISPLAY(NOT FALSE)       // TRUE\n```\n\n</details>\n\n<details>\n<summary><strong>IF / ELSE</strong></summary>\n\n```\nIF (condition) {\n    // runs if TRUE\n} ELSE {\n    // runs if FALSE  (ELSE block is optional)\n}\n```\n\n```\nx ← 7\nIF (x > 5) {\n    DISPLAY(\"big\")\n} ELSE {\n    DISPLAY(\"small\")\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Loops</strong></summary>\n\n**REPEAT n TIMES**\n```\nREPEAT 5 TIMES {\n    DISPLAY(\"hello\")\n}\n```\n\n**REPEAT UNTIL** — loops until condition is `TRUE`\n```\nx ← 0\nREPEAT UNTIL (x = 5) {\n    x ← x + 1\n}\n```\n\n**FOR EACH IN** — iterates over a list\n```\nFOR EACH n IN [1, 2, 3] {\n    DISPLAY(n * 2)\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Lists</strong></summary>\n\n**1-based indexing** — first element is at index `1`.\n\n| Command | What it does |\n|---|---|\n| `list[i]` | Get element at index `i` |\n| `list[i] ← value` | Set element at index `i` |\n| `APPEND(list, value)` | Add to end |\n| `INSERT(list, i, value)` | Insert at index `i` |\n| `REMOVE(list, i)` | Remove at index `i` |\n| `LENGTH(list)` | Number of elements |\n\n```\nnums ← [10, 20, 30]\nAPPEND(nums, 40)\nDISPLAY(LENGTH(nums))   // 4\nDISPLAY(nums[1])        // 10\n```\n\n</details>\n\n<details>\n<summary><strong>PROCEDURE &amp; RETURN</strong></summary>\n\n```\nPROCEDURE add(a, b) {\n    RETURN a + b\n}\nDISPLAY(add(3, 4))   // 7\n```\n\nProcedures without `RETURN` can still be called for side effects:\n```\nPROCEDURE greet(name) {\n    DISPLAY(\"Hello, \" + name)\n}\ngreet(\"Alice\")\n```\n\n</details>\n\n<details>\n<summary><strong>Robot / Grid Commands</strong></summary>\n\nThese activate the visual 7×7 grid. Write setup lines first, then movement logic below.\n\n**Setup** (stripped before execution)\n\n| Command | What it does |\n|---|---|\n| `from tilemaps import N` | Load preset map `N` (1–25) |\n| `spawn character at (col, row)` | Place robot at col, row (1-based), facing up |\n| `spawn goal at (col, row)` | Place a goal star |\n\n**Movement** (called at runtime)\n\n| Command | What it does |\n|---|---|\n| `MOVE_FORWARD()` | Move one cell forward |\n| `ROTATE_LEFT()` | Turn 90° counter-clockwise |\n| `ROTATE_RIGHT()` | Turn 90° clockwise |\n| `CAN_MOVE(\"direction\")` | `TRUE` if passable — `\"forward\"` `\"backward\"` `\"left\"` `\"right\"` |\n| `RENDER(matrix)` | Load a custom 7×7 list-of-lists as the grid (0=open, 1=wall) |\n\n```\nfrom tilemaps import 12\nspawn character at (1,1)\nspawn goal at (7,7)\n\nREPEAT UNTIL (CAN_MOVE(\"forward\") = FALSE) {\n    MOVE_FORWARD()\n}\nROTATE_RIGHT()\nMOVE_FORWARD()\n```\n\n</details>\n\n</details>"
   },
   {
    "cell_type": "markdown",

From de81578b12138acddb48162b506f40ea1d0d6449 Mon Sep 17 00:00:00 2001
From: RudraBJoshi <rudraj2022@gmail.com>
Date: Mon, 18 May 2026 11:27:38 -0700
Subject: [PATCH 3/6] Tile maps

---
 .../CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb b/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
index 460b9e57c7..d1030804cd 100644
--- a/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
+++ b/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
@@ -33,7 +33,7 @@
    "cell_type": "markdown",
    "id": "f63ef927",
    "metadata": {},
-   "source": "<details>\n<summary><strong>Pseudocode Keyword Reference</strong> (click to expand)</summary>\n\nAll keywords are **case-insensitive**. Type `<--` for `←`, `!=` for `≠`, `>=` for `≥`, `<=` for `≤`.\n\n<details>\n<summary><strong>Variables &amp; Assignment</strong></summary>\n\nUse `←` to assign a value. Variables are created on first assignment.\n\n```\nx ← 5\nname ← \"Alice\"\nflag ← TRUE\n```\n\n> Types: numbers, strings (`\"double quotes\"`), `TRUE` / `FALSE`\n\n</details>\n\n<details>\n<summary><strong>DISPLAY &amp; INPUT</strong></summary>\n\n| Command | What it does |\n|---|---|\n| `DISPLAY(value)` | Prints a value to the output box |\n| `INPUT(\"prompt\")` | Prompts the user; auto-converts to number/boolean if possible |\n\n```\nDISPLAY(\"Hello!\")\nage ← INPUT(\"Enter your age: \")\nDISPLAY(age)\n```\n\n</details>\n\n<details>\n<summary><strong>Operators</strong></summary>\n\n**Arithmetic:** `+` `-` `*` `/` `MOD`\n> `+` also concatenates strings\n\n**Comparison:** `=` `≠` `<` `>` `≤` `≥`\n\n**Logical:** `AND` `OR` `NOT`\n\n```\nDISPLAY(10 MOD 3)        // 1\nDISPLAY(5 = 5)           // TRUE\nDISPLAY(TRUE AND FALSE)  // FALSE\nDISPLAY(NOT FALSE)       // TRUE\n```\n\n</details>\n\n<details>\n<summary><strong>IF / ELSE</strong></summary>\n\n```\nIF (condition) {\n    // runs if TRUE\n} ELSE {\n    // runs if FALSE  (ELSE block is optional)\n}\n```\n\n```\nx ← 7\nIF (x > 5) {\n    DISPLAY(\"big\")\n} ELSE {\n    DISPLAY(\"small\")\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Loops</strong></summary>\n\n**REPEAT n TIMES**\n```\nREPEAT 5 TIMES {\n    DISPLAY(\"hello\")\n}\n```\n\n**REPEAT UNTIL** — loops until condition is `TRUE`\n```\nx ← 0\nREPEAT UNTIL (x = 5) {\n    x ← x + 1\n}\n```\n\n**FOR EACH IN** — iterates over a list\n```\nFOR EACH n IN [1, 2, 3] {\n    DISPLAY(n * 2)\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Lists</strong></summary>\n\n**1-based indexing** — first element is at index `1`.\n\n| Command | What it does |\n|---|---|\n| `list[i]` | Get element at index `i` |\n| `list[i] ← value` | Set element at index `i` |\n| `APPEND(list, value)` | Add to end |\n| `INSERT(list, i, value)` | Insert at index `i` |\n| `REMOVE(list, i)` | Remove at index `i` |\n| `LENGTH(list)` | Number of elements |\n\n```\nnums ← [10, 20, 30]\nAPPEND(nums, 40)\nDISPLAY(LENGTH(nums))   // 4\nDISPLAY(nums[1])        // 10\n```\n\n</details>\n\n<details>\n<summary><strong>PROCEDURE &amp; RETURN</strong></summary>\n\n```\nPROCEDURE add(a, b) {\n    RETURN a + b\n}\nDISPLAY(add(3, 4))   // 7\n```\n\nProcedures without `RETURN` can still be called for side effects:\n```\nPROCEDURE greet(name) {\n    DISPLAY(\"Hello, \" + name)\n}\ngreet(\"Alice\")\n```\n\n</details>\n\n<details>\n<summary><strong>Robot / Grid Commands</strong></summary>\n\nThese activate the visual 7×7 grid. Write setup lines first, then movement logic below.\n\n**Setup** (stripped before execution)\n\n| Command | What it does |\n|---|---|\n| `from tilemaps import N` | Load preset map `N` (1–25) |\n| `spawn character at (col, row)` | Place robot at col, row (1-based), facing up |\n| `spawn goal at (col, row)` | Place a goal star |\n\n**Movement** (called at runtime)\n\n| Command | What it does |\n|---|---|\n| `MOVE_FORWARD()` | Move one cell forward |\n| `ROTATE_LEFT()` | Turn 90° counter-clockwise |\n| `ROTATE_RIGHT()` | Turn 90° clockwise |\n| `CAN_MOVE(\"direction\")` | `TRUE` if passable — `\"forward\"` `\"backward\"` `\"left\"` `\"right\"` |\n| `RENDER(matrix)` | Load a custom 7×7 list-of-lists as the grid (0=open, 1=wall) |\n\n```\nfrom tilemaps import 12\nspawn character at (1,1)\nspawn goal at (7,7)\n\nREPEAT UNTIL (CAN_MOVE(\"forward\") = FALSE) {\n    MOVE_FORWARD()\n}\nROTATE_RIGHT()\nMOVE_FORWARD()\n```\n\n</details>\n\n</details>"
+   "source": "<details>\n<summary><strong>Pseudocode Keyword Reference</strong> (click to expand)</summary>\n\nAll keywords are **case-insensitive**. Type `<--` for `←`, `!=` for `≠`, `>=` for `≥`, `<=` for `≤`.\n\n<details>\n<summary><strong>Variables &amp; Assignment</strong></summary>\n\nUse `←` to assign a value. Variables are created on first assignment.\n\n```\nx ← 5\nname ← \"Alice\"\nflag ← TRUE\n```\n\n> Types: numbers, strings (`\"double quotes\"`), `TRUE` / `FALSE`\n\n</details>\n\n<details>\n<summary><strong>DISPLAY &amp; INPUT</strong></summary>\n\n| Command | What it does |\n|---|---|\n| `DISPLAY(value)` | Prints a value to the output box |\n| `INPUT(\"prompt\")` | Prompts the user; auto-converts to number/boolean if possible |\n\n```\nDISPLAY(\"Hello!\")\nage ← INPUT(\"Enter your age: \")\nDISPLAY(age)\n```\n\n</details>\n\n<details>\n<summary><strong>Operators</strong></summary>\n\n**Arithmetic:** `+` `-` `*` `/` `MOD`\n> `+` also concatenates strings\n\n**Comparison:** `=` `≠` `<` `>` `≤` `≥`\n\n**Logical:** `AND` `OR` `NOT`\n\n```\nDISPLAY(10 MOD 3)        // 1\nDISPLAY(5 = 5)           // TRUE\nDISPLAY(TRUE AND FALSE)  // FALSE\nDISPLAY(NOT FALSE)       // TRUE\n```\n\n</details>\n\n<details>\n<summary><strong>IF / ELSE</strong></summary>\n\n```\nIF (condition) {\n    // runs if TRUE\n} ELSE {\n    // runs if FALSE  (ELSE block is optional)\n}\n```\n\n```\nx ← 7\nIF (x > 5) {\n    DISPLAY(\"big\")\n} ELSE {\n    DISPLAY(\"small\")\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Loops</strong></summary>\n\n**REPEAT n TIMES**\n```\nREPEAT 5 TIMES {\n    DISPLAY(\"hello\")\n}\n```\n\n**REPEAT UNTIL** — loops until condition is `TRUE`\n```\nx ← 0\nREPEAT UNTIL (x = 5) {\n    x ← x + 1\n}\n```\n\n**FOR EACH IN** — iterates over a list\n```\nFOR EACH n IN [1, 2, 3] {\n    DISPLAY(n * 2)\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Lists</strong></summary>\n\n**1-based indexing** — first element is at index `1`.\n\n| Command | What it does |\n|---|---|\n| `list[i]` | Get element at index `i` |\n| `list[i] ← value` | Set element at index `i` |\n| `APPEND(list, value)` | Add to end |\n| `INSERT(list, i, value)` | Insert at index `i` |\n| `REMOVE(list, i)` | Remove at index `i` |\n| `LENGTH(list)` | Number of elements |\n\n```\nnums ← [10, 20, 30]\nAPPEND(nums, 40)\nDISPLAY(LENGTH(nums))   // 4\nDISPLAY(nums[1])        // 10\n```\n\n</details>\n\n<details>\n<summary><strong>PROCEDURE &amp; RETURN</strong></summary>\n\n```\nPROCEDURE add(a, b) {\n    RETURN a + b\n}\nDISPLAY(add(3, 4))   // 7\n```\n\nProcedures without `RETURN` can still be called for side effects:\n```\nPROCEDURE greet(name) {\n    DISPLAY(\"Hello, \" + name)\n}\ngreet(\"Alice\")\n```\n\n</details>\n\n<details>\n<summary><strong>Robot / Grid Commands</strong></summary>\n\nThese activate the visual 7×7 grid. Write setup lines first, then movement logic below.\n\n**Setup** (stripped before execution)\n\n| Command | What it does |\n|---|---|\n| `from tilemaps import N` | Load preset map `N` (1–25) |\n| `spawn character at (col, row)` | Place robot at col, row (1-based), facing up |\n| `spawn goal at (col, row)` | Place a goal star |\n\n**Movement** (called at runtime)\n\n| Command | What it does |\n|---|---|\n| `MOVE_FORWARD()` | Move one cell forward |\n| `ROTATE_LEFT()` | Turn 90° counter-clockwise |\n| `ROTATE_RIGHT()` | Turn 90° clockwise |\n| `CAN_MOVE(\"direction\")` | `TRUE` if passable — `\"forward\"` `\"backward\"` `\"left\"` `\"right\"` |\n\n```\nfrom tilemaps import 12\nspawn character at (1,1)\nspawn goal at (7,7)\n\nREPEAT UNTIL (CAN_MOVE(\"forward\") = FALSE) {\n    MOVE_FORWARD()\n}\nROTATE_RIGHT()\nMOVE_FORWARD()\n```\n\n</details>\n\n<details>\n<summary><strong>Custom Tilemaps (RENDER)</strong></summary>\n\nInstead of loading a preset with `from tilemaps import`, you can define your own 7×7 grid as a variable and pass it to `RENDER()`.\n\n**Rules:**\n- The matrix must be a **list of 7 lists**, each with exactly **7 values**\n- `0` = open cell, `1` = wall\n- The entire assignment must be on **one line** — multi-line expressions are not supported\n- Call `RENDER(variable)` before any movement commands\n\n```\nmyMap ← [[0,0,0,0,0,0,0],[0,1,1,0,0,1,0],[0,0,1,0,0,0,0],[0,0,0,0,1,0,0],[0,1,0,0,1,0,0],[0,1,0,0,0,0,0],[0,0,0,0,0,0,0]]\n\nspawn character at (1,1)\nspawn goal at (7,7)\n\nRENDER(myMap)\nMOVE_FORWARD()\nROTATE_RIGHT()\nMOVE_FORWARD()\n```\n\n> You can still combine both: use `from tilemaps import N` to load a preset, then call `RENDER(newMap)` later in your code to swap the grid mid-execution.\n\n</details>\n\n</details>"
   },
   {
    "cell_type": "markdown",

From 4d89a112ef062ab59a3b4b2be6c0584f9e1fbb3d Mon Sep 17 00:00:00 2001
From: RudraBJoshi <rudraj2022@gmail.com>
Date: Mon, 18 May 2026 13:24:36 -0700
Subject: [PATCH 4/6] directions

---
 .../executors/Pseudosystem_Executors/RobotExecutor.js    | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js b/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
index 9a05a4e628..44cd17b656 100644
--- a/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
+++ b/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
@@ -84,8 +84,13 @@ function simulate(pseudoSrc, initialGrid, startCol, startRow) {
   };
 
   const CAN_MOVE = (dirName) => {
-    const d = DIR_NAMES.indexOf(String(dirName).toLowerCase());
-    if (d === -1) throw new Error(`AP CSP Robot Error: CAN_MOVE got unknown direction "${dirName}"`);
+    const rel = String(dirName).toLowerCase();
+    let d;
+    if      (rel === 'forward')  d = dir;
+    else if (rel === 'backward') d = (dir + 2) % 4;
+    else if (rel === 'left')     d = (dir + 3) % 4;
+    else if (rel === 'right')    d = (dir + 1) % 4;
+    else throw new Error(`AP CSP Robot Error: CAN_MOVE got unknown direction "${dirName}" — use "forward", "backward", "left", or "right"`);
     const { dr, dc } = DIR_DELTA[d];
     const nr = row + dr, nc = col + dc;
     return !(nr < 0 || nr >= GRID || nc < 0 || nc >= GRID || grid[nr][nc] === 1);

From 5760cb7f01af6cae885f4618c3da193c2eee001e Mon Sep 17 00:00:00 2001
From: RudraBJoshi <rudraj2022@gmail.com>
Date: Mon, 18 May 2026 13:29:35 -0700
Subject: [PATCH 5/6] Case-sensitive, all caps required

---
 _includes/runners/code.html                        |  4 ++--
 .../2026-05-12-AP-CSP_Pseudocode_runner.ipynb      |  4 ++--
 .../Pseudosystem_Executors/PseudocodeExecutor.js   |  3 +--
 .../Pseudosystem_Executors/RobotExecutor.js        | 14 +++++++-------
 4 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/_includes/runners/code.html b/_includes/runners/code.html
index fc28c3c14e..7ae4cf4a34 100644
--- a/_includes/runners/code.html
+++ b/_includes/runners/code.html
@@ -88,10 +88,10 @@
 
         // Words: robot commands take priority, then pseudocode keywords
         if (stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/)) {
-          const w = stream.current().toUpperCase();
+          const w = stream.current();
           if (KW.has(w) || KW_EXTRA.has(w)) return 'keyword';
           if (BI.has(w) || BI_EXTRA.has(w)) return 'builtin';
-          if (BOOL.has(w))         return 'atom';
+          if (BOOL.has(w))                  return 'atom';
           return 'variable';
         }
 
diff --git a/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb b/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
index d1030804cd..10d02b8f04 100644
--- a/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
+++ b/_notebooks/CSP/AP-prep/2026-05-12-AP-CSP_Pseudocode_runner.ipynb
@@ -33,13 +33,13 @@
    "cell_type": "markdown",
    "id": "f63ef927",
    "metadata": {},
-   "source": "<details>\n<summary><strong>Pseudocode Keyword Reference</strong> (click to expand)</summary>\n\nAll keywords are **case-insensitive**. Type `<--` for `←`, `!=` for `≠`, `>=` for `≥`, `<=` for `≤`.\n\n<details>\n<summary><strong>Variables &amp; Assignment</strong></summary>\n\nUse `←` to assign a value. Variables are created on first assignment.\n\n```\nx ← 5\nname ← \"Alice\"\nflag ← TRUE\n```\n\n> Types: numbers, strings (`\"double quotes\"`), `TRUE` / `FALSE`\n\n</details>\n\n<details>\n<summary><strong>DISPLAY &amp; INPUT</strong></summary>\n\n| Command | What it does |\n|---|---|\n| `DISPLAY(value)` | Prints a value to the output box |\n| `INPUT(\"prompt\")` | Prompts the user; auto-converts to number/boolean if possible |\n\n```\nDISPLAY(\"Hello!\")\nage ← INPUT(\"Enter your age: \")\nDISPLAY(age)\n```\n\n</details>\n\n<details>\n<summary><strong>Operators</strong></summary>\n\n**Arithmetic:** `+` `-` `*` `/` `MOD`\n> `+` also concatenates strings\n\n**Comparison:** `=` `≠` `<` `>` `≤` `≥`\n\n**Logical:** `AND` `OR` `NOT`\n\n```\nDISPLAY(10 MOD 3)        // 1\nDISPLAY(5 = 5)           // TRUE\nDISPLAY(TRUE AND FALSE)  // FALSE\nDISPLAY(NOT FALSE)       // TRUE\n```\n\n</details>\n\n<details>\n<summary><strong>IF / ELSE</strong></summary>\n\n```\nIF (condition) {\n    // runs if TRUE\n} ELSE {\n    // runs if FALSE  (ELSE block is optional)\n}\n```\n\n```\nx ← 7\nIF (x > 5) {\n    DISPLAY(\"big\")\n} ELSE {\n    DISPLAY(\"small\")\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Loops</strong></summary>\n\n**REPEAT n TIMES**\n```\nREPEAT 5 TIMES {\n    DISPLAY(\"hello\")\n}\n```\n\n**REPEAT UNTIL** — loops until condition is `TRUE`\n```\nx ← 0\nREPEAT UNTIL (x = 5) {\n    x ← x + 1\n}\n```\n\n**FOR EACH IN** — iterates over a list\n```\nFOR EACH n IN [1, 2, 3] {\n    DISPLAY(n * 2)\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Lists</strong></summary>\n\n**1-based indexing** — first element is at index `1`.\n\n| Command | What it does |\n|---|---|\n| `list[i]` | Get element at index `i` |\n| `list[i] ← value` | Set element at index `i` |\n| `APPEND(list, value)` | Add to end |\n| `INSERT(list, i, value)` | Insert at index `i` |\n| `REMOVE(list, i)` | Remove at index `i` |\n| `LENGTH(list)` | Number of elements |\n\n```\nnums ← [10, 20, 30]\nAPPEND(nums, 40)\nDISPLAY(LENGTH(nums))   // 4\nDISPLAY(nums[1])        // 10\n```\n\n</details>\n\n<details>\n<summary><strong>PROCEDURE &amp; RETURN</strong></summary>\n\n```\nPROCEDURE add(a, b) {\n    RETURN a + b\n}\nDISPLAY(add(3, 4))   // 7\n```\n\nProcedures without `RETURN` can still be called for side effects:\n```\nPROCEDURE greet(name) {\n    DISPLAY(\"Hello, \" + name)\n}\ngreet(\"Alice\")\n```\n\n</details>\n\n<details>\n<summary><strong>Robot / Grid Commands</strong></summary>\n\nThese activate the visual 7×7 grid. Write setup lines first, then movement logic below.\n\n**Setup** (stripped before execution)\n\n| Command | What it does |\n|---|---|\n| `from tilemaps import N` | Load preset map `N` (1–25) |\n| `spawn character at (col, row)` | Place robot at col, row (1-based), facing up |\n| `spawn goal at (col, row)` | Place a goal star |\n\n**Movement** (called at runtime)\n\n| Command | What it does |\n|---|---|\n| `MOVE_FORWARD()` | Move one cell forward |\n| `ROTATE_LEFT()` | Turn 90° counter-clockwise |\n| `ROTATE_RIGHT()` | Turn 90° clockwise |\n| `CAN_MOVE(\"direction\")` | `TRUE` if passable — `\"forward\"` `\"backward\"` `\"left\"` `\"right\"` |\n\n```\nfrom tilemaps import 12\nspawn character at (1,1)\nspawn goal at (7,7)\n\nREPEAT UNTIL (CAN_MOVE(\"forward\") = FALSE) {\n    MOVE_FORWARD()\n}\nROTATE_RIGHT()\nMOVE_FORWARD()\n```\n\n</details>\n\n<details>\n<summary><strong>Custom Tilemaps (RENDER)</strong></summary>\n\nInstead of loading a preset with `from tilemaps import`, you can define your own 7×7 grid as a variable and pass it to `RENDER()`.\n\n**Rules:**\n- The matrix must be a **list of 7 lists**, each with exactly **7 values**\n- `0` = open cell, `1` = wall\n- The entire assignment must be on **one line** — multi-line expressions are not supported\n- Call `RENDER(variable)` before any movement commands\n\n```\nmyMap ← [[0,0,0,0,0,0,0],[0,1,1,0,0,1,0],[0,0,1,0,0,0,0],[0,0,0,0,1,0,0],[0,1,0,0,1,0,0],[0,1,0,0,0,0,0],[0,0,0,0,0,0,0]]\n\nspawn character at (1,1)\nspawn goal at (7,7)\n\nRENDER(myMap)\nMOVE_FORWARD()\nROTATE_RIGHT()\nMOVE_FORWARD()\n```\n\n> You can still combine both: use `from tilemaps import N` to load a preset, then call `RENDER(newMap)` later in your code to swap the grid mid-execution.\n\n</details>\n\n</details>"
+   "source": "<details>\n<summary><strong>Pseudocode Keyword Reference</strong> (click to expand)</summary>\n\nAll keywords are **case-sensitive and must be written in ALL CAPS**. Type `<--` for `\u2190`, `!=` for `\u2260`, `>=` for `\u2265`, `<=` for `\u2264`.\n\n<details>\n<summary><strong>Variables &amp; Assignment</strong></summary>\n\nUse `\u2190` to assign a value. Variables are created on first assignment. Variable names are case-sensitive.\n\n```\nx \u2190 5\nname \u2190 \"Alice\"\nflag \u2190 TRUE\n```\n\n> Types: numbers, strings (`\"double quotes\"`), `TRUE` / `FALSE`\n\n</details>\n\n<details>\n<summary><strong>DISPLAY &amp; INPUT</strong></summary>\n\n| Command | What it does |\n|---|---|\n| `DISPLAY(value)` | Prints a value to the output box |\n| `INPUT(\"prompt\")` | Prompts the user; auto-converts to number/boolean if possible |\n\n```\nDISPLAY(\"Hello!\")\nage \u2190 INPUT(\"Enter your age: \")\nDISPLAY(age)\n```\n\n</details>\n\n<details>\n<summary><strong>Operators</strong></summary>\n\n**Arithmetic:** `+` `-` `*` `/` `MOD`\n> `+` also concatenates strings\n\n**Comparison:** `=` `\u2260` `<` `>` `\u2264` `\u2265`\n\n**Logical:** `AND` `OR` `NOT`\n\n```\nDISPLAY(10 MOD 3)        // 1\nDISPLAY(5 = 5)           // TRUE\nDISPLAY(TRUE AND FALSE)  // FALSE\nDISPLAY(NOT FALSE)       // TRUE\n```\n\n</details>\n\n<details>\n<summary><strong>IF / ELSE</strong></summary>\n\n```\nIF (condition) {\n    // runs if TRUE\n} ELSE {\n    // runs if FALSE  (ELSE block is optional)\n}\n```\n\n```\nx \u2190 7\nIF (x > 5) {\n    DISPLAY(\"big\")\n} ELSE {\n    DISPLAY(\"small\")\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Loops</strong></summary>\n\n**REPEAT n TIMES**\n```\nREPEAT 5 TIMES {\n    DISPLAY(\"hello\")\n}\n```\n\n**REPEAT UNTIL** \u2014 loops until condition is `TRUE`\n```\nx \u2190 0\nREPEAT UNTIL (x = 5) {\n    x \u2190 x + 1\n}\n```\n\n**FOR EACH IN** \u2014 iterates over a list\n```\nFOR EACH n IN [1, 2, 3] {\n    DISPLAY(n * 2)\n}\n```\n\n</details>\n\n<details>\n<summary><strong>Lists</strong></summary>\n\n**1-based indexing** \u2014 first element is at index `1`.\n\n| Command | What it does |\n|---|---|\n| `list[i]` | Get element at index `i` |\n| `list[i] \u2190 value` | Set element at index `i` |\n| `APPEND(list, value)` | Add to end |\n| `INSERT(list, i, value)` | Insert at index `i` |\n| `REMOVE(list, i)` | Remove at index `i` |\n| `LENGTH(list)` | Number of elements |\n\n```\nnums \u2190 [10, 20, 30]\nAPPEND(nums, 40)\nDISPLAY(LENGTH(nums))   // 4\nDISPLAY(nums[1])        // 10\n```\n\n</details>\n\n<details>\n<summary><strong>PROCEDURE &amp; RETURN</strong></summary>\n\n```\nPROCEDURE add(a, b) {\n    RETURN a + b\n}\nDISPLAY(add(3, 4))   // 7\n```\n\nProcedures without `RETURN` can still be called for side effects:\n```\nPROCEDURE greet(name) {\n    DISPLAY(\"Hello, \" + name)\n}\ngreet(\"Alice\")\n```\n\n</details>\n\n<details>\n<summary><strong>Robot / Grid Commands</strong></summary>\n\nThese activate the visual 7x7 grid. Write setup lines first, then movement logic below.\n\n**Setup** (stripped before execution)\n\n| Command | What it does |\n|---|---|\n| `FROM TILEMAPS IMPORT N` | Load preset map N (1-25) |\n| `SPAWN CHARACTER AT (col, row)` | Place robot at col, row (1-based), facing up |\n| `SPAWN GOAL AT (col, row)` | Place a goal star |\n\n**Movement** (called at runtime)\n\n| Command | What it does |\n|---|---|\n| `MOVE_FORWARD()` | Move one cell forward |\n| `ROTATE_LEFT()` | Turn 90 degrees counter-clockwise |\n| `ROTATE_RIGHT()` | Turn 90 degrees clockwise |\n| `CAN_MOVE(\"direction\")` | TRUE if passable - \"forward\" \"backward\" \"left\" \"right\" |\n\n```\nFROM TILEMAPS IMPORT 12\nSPAWN CHARACTER AT (1,1)\nSPAWN GOAL AT (7,7)\n\nREPEAT UNTIL (CAN_MOVE(\"forward\") = FALSE) {\n    MOVE_FORWARD()\n}\nROTATE_RIGHT()\nMOVE_FORWARD()\n```\n\n</details>\n\n<details>\n<summary><strong>Custom Tilemaps (RENDER)</strong></summary>\n\nInstead of loading a preset with `FROM TILEMAPS IMPORT`, define your own 7x7 grid as a variable and pass it to `RENDER()`.\n\n**Rules:**\n- The matrix must be a **list of 7 lists**, each with exactly **7 values**\n- `0` = open cell, `1` = wall\n- The entire assignment must be on **one line**\n- Call `RENDER(variable)` before any movement commands\n\n```\nmyMap \u2190 [[0,0,0,0,0,0,0],[0,1,1,0,0,1,0],[0,0,1,0,0,0,0],[0,0,0,0,1,0,0],[0,1,0,0,1,0,0],[0,1,0,0,0,0,0],[0,0,0,0,0,0,0]]\n\nSPAWN CHARACTER AT (1,1)\nSPAWN GOAL AT (7,7)\n\nRENDER(myMap)\nMOVE_FORWARD()\nROTATE_RIGHT()\nMOVE_FORWARD()\n```\n\n> You can combine both: use `FROM TILEMAPS IMPORT N` to load a preset, then call `RENDER(newMap)` later to swap the grid mid-execution.\n\n</details>\n\n</details>"
   },
   {
    "cell_type": "markdown",
    "id": "513a92fa",
    "metadata": {},
-   "source": "<details>\n<summary><strong>Tilemap Directory</strong> — IDs 1–25 (click to expand)</summary>\n\nUse these IDs with `from tilemaps import N`. All maps are 7×7, 0 = open, 1 = wall.\n\n| ID | Name | Description |\n|---|---|---|\n| 1 | Scattered walls | Open grid with a few wall clusters — good starter map |\n| 2 | Column gaps | Vertical wall pairs with clear corridors between them |\n| 3 | Double gate | Two horizontal barriers each with a single opening in the centre |\n| 4 | Staggered columns | Alternating column walls; open row in the middle connects them |\n| 5 | Ring | Solid 5×5 wall ring with an open interior and outer path |\n| 6 | Diamond obstacles | Symmetric diagonal obstacles around a centre wall |\n| 7 | Cross barrier | Plus-sign wall with a single gap on each axis |\n| 8 | Dot grid | Regular 2×2 wall dots across the grid — many equal paths |\n| 9 | S-curve | Single-width path: left → down → right → down |\n| 10 | T-junction | Open top row splits into two shafts that merge to a single exit |\n| 11 | Two rooms | Wall divides the grid; one corridor connects the rooms at row 4 |\n| 12 | Zigzag slalom | Barriers alternate sides — forces full end-to-end traversal |\n| 13 | Diagonal obstacles | Diagonal line of single-cell walls; open space on both sides |\n| 14 | Slalom barriers | Two staggered barriers each with one opening — weave through |\n| 15 | Winding river | Narrow single-width path snaking from top-left to bottom-right |\n| 16 | Cross open | Plus-sign open area in the centre; corners are walled off |\n| 17 | Perimeter loop | Outer ring is fully open; solid 5×5 block in the interior |\n| 18 | Grid maze | Open intersections with wall segments — multiple valid routes |\n| 19 | Columns | Tall wall columns with one open row in the middle |\n| 20 | Honeycomb | Staggered single-cell obstacles; lots of routing options |\n| 21 | Staircase | 2-wide diagonal path from top-left to bottom-right |\n| 22 | Scattered obstacles | Mostly open with light random single-cell walls |\n| 23 | L-corridor | Left column + bottom row form an L-shaped path |\n| 24 | Double loop | Four 2×2 wall blocks leave open rings and a centre cross |\n| 25 | Funnel | Wide open top narrows to a single-column corridor at the bottom |\n\n</details>"
+   "source": "<details>\n<summary><strong>Tilemap Directory</strong> \u2014 IDs 1\u201325 (click to expand)</summary>\n\nUse these IDs with `from tilemaps import N`. All maps are 7\u00d77, 0 = open, 1 = wall.\n\n| ID | Name | Description |\n|---|---|---|\n| 1 | Scattered walls | Open grid with a few wall clusters \u2014 good starter map |\n| 2 | Column gaps | Vertical wall pairs with clear corridors between them |\n| 3 | Double gate | Two horizontal barriers each with a single opening in the centre |\n| 4 | Staggered columns | Alternating column walls; open row in the middle connects them |\n| 5 | Ring | Solid 5\u00d75 wall ring with an open interior and outer path |\n| 6 | Diamond obstacles | Symmetric diagonal obstacles around a centre wall |\n| 7 | Cross barrier | Plus-sign wall with a single gap on each axis |\n| 8 | Dot grid | Regular 2\u00d72 wall dots across the grid \u2014 many equal paths |\n| 9 | S-curve | Single-width path: left \u2192 down \u2192 right \u2192 down |\n| 10 | T-junction | Open top row splits into two shafts that merge to a single exit |\n| 11 | Two rooms | Wall divides the grid; one corridor connects the rooms at row 4 |\n| 12 | Zigzag slalom | Barriers alternate sides \u2014 forces full end-to-end traversal |\n| 13 | Diagonal obstacles | Diagonal line of single-cell walls; open space on both sides |\n| 14 | Slalom barriers | Two staggered barriers each with one opening \u2014 weave through |\n| 15 | Winding river | Narrow single-width path snaking from top-left to bottom-right |\n| 16 | Cross open | Plus-sign open area in the centre; corners are walled off |\n| 17 | Perimeter loop | Outer ring is fully open; solid 5\u00d75 block in the interior |\n| 18 | Grid maze | Open intersections with wall segments \u2014 multiple valid routes |\n| 19 | Columns | Tall wall columns with one open row in the middle |\n| 20 | Honeycomb | Staggered single-cell obstacles; lots of routing options |\n| 21 | Staircase | 2-wide diagonal path from top-left to bottom-right |\n| 22 | Scattered obstacles | Mostly open with light random single-cell walls |\n| 23 | L-corridor | Left column + bottom row form an L-shaped path |\n| 24 | Double loop | Four 2\u00d72 wall blocks leave open rings and a centre cross |\n| 25 | Funnel | Wide open top narrows to a single-column corridor at the bottom |\n\n</details>"
   },
   {
    "cell_type": "markdown",
diff --git a/assets/js/pages/runners/executors/Pseudosystem_Executors/PseudocodeExecutor.js b/assets/js/pages/runners/executors/Pseudosystem_Executors/PseudocodeExecutor.js
index 610a40cace..6b31695bb6 100644
--- a/assets/js/pages/runners/executors/Pseudosystem_Executors/PseudocodeExecutor.js
+++ b/assets/js/pages/runners/executors/Pseudosystem_Executors/PseudocodeExecutor.js
@@ -28,8 +28,7 @@ function tokenize(src) {
     }
     if (/[a-zA-Z_]/.test(c)) {
       let s = ''; while (i < n && /[a-zA-Z0-9_]/.test(src[i])) s += src[i++];
-      const u = s.toUpperCase();
-      out.push({t: KW.has(u) ? 'K' : 'I', v: KW.has(u) ? u : s}); continue;
+      out.push({t: KW.has(s) ? 'K' : 'I', v: s}); continue;
     }
     const sl = src.slice(i);
     if (sl.slice(0,3) === '<--') { out.push({t:'O',v:'←'}); i+=3; continue; }
diff --git a/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js b/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
index 44cd17b656..bd36ea0e9e 100644
--- a/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
+++ b/assets/js/pages/runners/executors/Pseudosystem_Executors/RobotExecutor.js
@@ -29,13 +29,13 @@ function parseSource(src) {
   for (const raw of src.split('\n')) {
     const line = raw.trim();
 
-    const mMap = line.match(/^from\s+tilemaps\s+import\s+(\d+)$/i);
+    const mMap = line.match(/^FROM\s+TILEMAPS\s+IMPORT\s+(\d+)$/);
     if (mMap) { tilemapId = parseInt(mMap[1], 10); continue; }
 
-    const mSpawn = line.match(/^spawn\s+character\s+at\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)$/i);
+    const mSpawn = line.match(/^SPAWN\s+CHARACTER\s+AT\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)$/);
     if (mSpawn) { spawnCol = parseInt(mSpawn[1], 10) - 1; spawnRow = parseInt(mSpawn[2], 10) - 1; continue; }
 
-    const mGoal = line.match(/^spawn\s+goal\s+at\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)$/i);
+    const mGoal = line.match(/^SPAWN\s+GOAL\s+AT\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)$/);
     if (mGoal) { goalCol = parseInt(mGoal[1], 10) - 1; goalRow = parseInt(mGoal[2], 10) - 1; continue; }
 
     codeLines.push(raw);
@@ -253,10 +253,10 @@ export class RobotExecutor {
   }
 
   static detect(src) {
-    return /^\s*from\s+tilemaps\s+import\s+\d+/im.test(src) ||
-           /^\s*spawn\s+character\s+at/im.test(src)         ||
-           /^\s*spawn\s+goal\s+at/im.test(src)              ||
-           /\bRENDER\s*\(/i.test(src);
+    return /^\s*FROM\s+TILEMAPS\s+IMPORT\s+\d+/m.test(src) ||
+           /^\s*SPAWN\s+CHARACTER\s+AT/m.test(src)         ||
+           /^\s*SPAWN\s+GOAL\s+AT/m.test(src)              ||
+           /\bRENDER\s*\(/.test(src);
   }
 
   run(src) {

From 3d7a891f1a7f32e9e4e1ca7074c2b32c2395b4a8 Mon Sep 17 00:00:00 2001
From: RudraBJoshi <rudraj2022@gmail.com>
Date: Mon, 18 May 2026 13:37:53 -0700
Subject: [PATCH 6/6] color match

---
 _includes/runners/code.html | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/_includes/runners/code.html b/_includes/runners/code.html
index 7ae4cf4a34..707d42bdf0 100644
--- a/_includes/runners/code.html
+++ b/_includes/runners/code.html
@@ -64,8 +64,9 @@
     const BI         = new Set(['DISPLAY','INPUT','APPEND','INSERT','REMOVE','LENGTH']);
     const BOOL       = new Set(['TRUE','FALSE']);
     // Robot commands folded into existing token types for colour consistency
-    const BI_EXTRA = new Set(['MOVE_FORWARD','ROTATE_LEFT','ROTATE_RIGHT','CAN_MOVE','RENDER']);
-    const KW_EXTRA = new Set(['SPAWN','CHARACTER','GOAL','AT','FROM','TILEMAPS','IMPORT']);
+    const BI_EXTRA     = new Set(['MOVE_FORWARD','ROTATE_LEFT','ROTATE_RIGHT','CAN_MOVE','RENDER']);
+    const ROBOT_BLUE   = new Set(['FROM','TILEMAPS','IMPORT','SPAWN']);
+    const ROBOT_YELLOW = new Set(['CHARACTER','GOAL']);
     return {
       token: function(stream) {
         if (stream.eatSpace()) return null;
@@ -89,9 +90,11 @@
         // Words: robot commands take priority, then pseudocode keywords
         if (stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/)) {
           const w = stream.current();
-          if (KW.has(w) || KW_EXTRA.has(w)) return 'keyword';
+          if (KW.has(w))                     return 'keyword';
           if (BI.has(w) || BI_EXTRA.has(w)) return 'builtin';
           if (BOOL.has(w))                  return 'atom';
+          if (ROBOT_BLUE.has(w))            return 'attribute';
+          if (ROBOT_YELLOW.has(w))          return 'property';
           return 'variable';
         }