From 4ef5c60a72b2157bca17b8184d65ffe6122ef899 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 11:38:00 -0500
Subject: [PATCH 01/39] Beginning to understand file structure, added a summary
 MD file to help me identify what routes to replace with the Flask alternative

---
 package-lock.json             | 12 ++++++++++++
 requirements.txt              |  3 +++
 src/routes/+page.svelte       | 35 ++++++++++++++++++++++++++---------
 src/routes/backend.py         | 31 +++++++++++++++++++++++++++++++
 src/routes/summary.md         | 20 ++++++++++++++++++++
 static/examples/manifest.json |  6 +++---
 6 files changed, 95 insertions(+), 12 deletions(-)
 create mode 100644 requirements.txt
 create mode 100644 src/routes/backend.py
 create mode 100644 src/routes/summary.md

diff --git a/package-lock.json b/package-lock.json
index 68522769..5ea53ba9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1218,6 +1218,7 @@
       "integrity": "sha512-Vp3zX/qlwerQmHMP6x0Ry1oY7eKKRcOWGc2P59srOp4zcqyn+etJyQpELgOi4+ZSUgteX8Y387NuwruLgGXLUQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@standard-schema/spec": "^1.0.0",
         "@sveltejs/acorn-typescript": "^1.0.5",
@@ -1257,6 +1258,7 @@
       "integrity": "sha512-YZs/OSKOQAQCnJvM/P+F1URotNnYNeU3P2s4oIpzm1uFaqUEqRxUB0g5ejMjEb5Gjb9/PiBI5Ktrq4rUUF8UVQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@sveltejs/vite-plugin-svelte-inspector": "^5.0.0",
         "debug": "^4.4.1",
@@ -1365,6 +1367,7 @@
       "integrity": "sha512-1N9SBnWYOJTrNZCdh/yJE+t910Y128BoyY+zBLWhL3r0TYzlTmFdXrPwHL9DyFZmlEXNQQolTZh3KHV31QDhyA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "undici-types": "~6.21.0"
       }
@@ -1411,6 +1414,7 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -1708,6 +1712,7 @@
       "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
       "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
       "license": "ISC",
+      "peer": true,
       "engines": {
         "node": ">=12"
       }
@@ -1858,6 +1863,7 @@
       "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -2590,6 +2596,7 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -2623,6 +2630,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -2746,6 +2754,7 @@
       "integrity": "sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -2973,6 +2982,7 @@
       "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.46.0.tgz",
       "integrity": "sha512-ZhLtvroYxUxr+HQJfMZEDRsGsmU46x12RvAv/zi9584f5KOX7bUrEbhPJ7cKFmUvZTJXi/CFZUYwDC6M1FigPw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@jridgewell/remapping": "^2.3.4",
         "@jridgewell/sourcemap-codec": "^1.5.0",
@@ -3140,6 +3150,7 @@
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -3178,6 +3189,7 @@
       "integrity": "sha512-dZwN5L1VlUBewiP6H9s2+B3e3Jg96D0vzN+Ry73sOefebhYr9f94wwkMNN/9ouoU8pV1BqA1d1zGk8928cx0rg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "esbuild": "^0.27.0",
         "fdir": "^6.5.0",
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 00000000..e2b61fe7
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,3 @@
+# Web application dependencies (not needed for core package)
+Flask>=3.1.1
+flask-cors>=6.0.1
\ No newline at end of file
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 76ea3699..52f7f087 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -1,8 +1,12 @@
 <script lang="ts">
+	// --------------------------- ROOT PAGE IMPORTS | START ---------------------------
+	// Svelte Package imports
 	import { onMount } from 'svelte';
     import { base } from '$app/paths';
 	import { fly, fade, scale } from 'svelte/transition';
 	import { cubicOut } from 'svelte/easing';
+
+	// Svelte Component Imports
 	import FlowCanvas from '$lib/components/FlowCanvas.svelte';
 	import SimulationPanel from '$lib/components/panels/SimulationPanel.svelte';
 	import BlockPropertiesDialog from '$lib/components/dialogs/BlockPropertiesDialog.svelte';
@@ -23,10 +27,9 @@
 	import WelcomeModal from '$lib/components/WelcomeModal.svelte';
 	import SubsystemBreadcrumb from '$lib/components/SubsystemBreadcrumb.svelte';
 	import Icon from '$lib/components/icons/Icon.svelte';
-	import { nodeRegistry } from '$lib/nodes';
-	import { NODE_TYPES } from '$lib/constants/nodeTypes';
-	import { PANEL_GAP, PANEL_TOGGLES_WIDTH, MIN_BOTTOM_PANEL_WIDTH, PANEL_DEFAULTS, NAV_HEIGHT } from '$lib/constants/layout';
-	import { DEFAULT_SIMULATION_SETTINGS } from '$lib/nodes/types';
+	import Tooltip, { tooltip } from '$lib/components/Tooltip.svelte';
+
+	// Stores (and Registry) imports
 	import { graphStore } from '$lib/stores/graph';
 	import { eventStore } from '$lib/stores/events';
 	import { historyStore } from '$lib/stores/history';
@@ -34,19 +37,33 @@
 	import { codeContextStore } from '$lib/stores/codeContext';
 	import { themeStore, type Theme } from '$lib/stores/theme';
 	import { contextMenuStore, type ContextMenuTarget } from '$lib/stores/contextMenu';
+	import { consoleStore } from '$lib/stores/console';
+	import { nodeUpdatesStore } from '$lib/stores/nodeUpdates';
+	import { pinnedPreviewsStore } from '$lib/stores/pinnedPreviews';
+	import { clipboardStore } from '$lib/stores/clipboard';
+	import { nodeRegistry } from '$lib/nodes';
+
+	// Dialog imports
 	import { openNodeDialog } from '$lib/stores/nodeDialog';
 	import { openEventDialog } from '$lib/stores/eventDialog';
+
+	// Constants and type imports
 	import type { MenuItemType } from '$lib/components/ContextMenu.svelte';
+	import { NODE_TYPES } from '$lib/constants/nodeTypes';
+	import { PANEL_GAP, PANEL_TOGGLES_WIDTH, MIN_BOTTOM_PANEL_WIDTH, PANEL_DEFAULTS, NAV_HEIGHT } from '$lib/constants/layout';
+	import { DEFAULT_SIMULATION_SETTINGS } from '$lib/nodes/types';
+
+	// Pyodide and Python Functionality imports
 	import { pyodideState, simulationState, initPyodide, stopSimulation, continueStreamingSimulation } from '$lib/pyodide/bridge';
 	import { runGraphStreamingSimulation, validateGraphSimulation } from '$lib/pyodide/pathsimRunner';
-	import { consoleStore } from '$lib/stores/console';
+
+	// Console Specific Settings and Actions
 	import { newGraph, openFile, saveFile, saveAsFile, setupAutoSave, clearAutoSave, debouncedAutoSave, loadGraphFromUrl, currentFileName } from '$lib/schema/fileOps';
 	import { triggerFitView, triggerZoomIn, triggerZoomOut, triggerPan, getViewportCenter, screenToFlow, triggerClearSelection, triggerNudge, hasAnySelection, setFitViewPadding } from '$lib/stores/viewActions';
-	import { nodeUpdatesStore } from '$lib/stores/nodeUpdates';
-	import { pinnedPreviewsStore } from '$lib/stores/pinnedPreviews';
-	import { clipboardStore } from '$lib/stores/clipboard';
-	import Tooltip, { tooltip } from '$lib/components/Tooltip.svelte';
 
+	// --------------------------- ROOT PAGE IMPORTS | END ---------------------------
+
+	
 	// Track mouse position for paste operations
 	let mousePosition = $state({ x: 0, y: 0 });
 
diff --git a/src/routes/backend.py b/src/routes/backend.py
new file mode 100644
index 00000000..f8e11fea
--- /dev/null
+++ b/src/routes/backend.py
@@ -0,0 +1,31 @@
+import os
+import json
+import requests as req
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+app = Flask(__name__, static_folder="../static", static_url_path="")
+
+if os.getenv("FLASK_ENV") == "production":
+    CORS(app,
+         resources={
+             r"/*": {
+                 "origins": ["*"],
+                 "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+                 "allow_headers": ["Content-Type", "Authorization"]
+             } 
+         })
+else:
+    CORS(
+        app, 
+        reosurces={
+            r"/*": {""
+                "origins": {"origins": ["http://localhost:5173", "http://localhost:3000"]}
+            }
+        },
+        supports_credentials=True
+    )
+
+if __name__ == "__Main__":
+    port = int(os.getenv("PORT", 800)) 
+    app.run(host="0.0.0.0", port=port, debug=os.getenv("FLASK_ENV") != "production")
\ No newline at end of file
diff --git a/src/routes/summary.md b/src/routes/summary.md
new file mode 100644
index 00000000..925b0fef
--- /dev/null
+++ b/src/routes/summary.md
@@ -0,0 +1,20 @@
+# Imports Summary
+### For the purpose of better understanding the project and isolating that functionality which will be attributed to a Flask backend, I commented these imports and split them up
+
+This is a page that quickly runs through the top level imports in the root Svelte page for PathView
+For this purpose of implementing backend functionality that provides an alternative to Pyodide the most relevant
+
+#### **Svelte Default Imports** *(irrelevant to backend)*  
+Simple packages imported from Svelte for the purpose of transition animations and other native tools
+
+#### **Svelte Component Imports** *(irrelevant to backend)*  
+These are the custom UI Components that are rendered on the home page
+
+#### **Store (and Registry) Imports** *(possibly relevant to backend?)*  
+From what I can see these stores help organize the data organization of multiple data structures whether that includes core data structures like graphs and events or abitrary. Core to all of this functionality is the Svelte writable 
+
+#### **Pyodide and Python Functionality Imports** *(relevant to backend)*
+These are the functions and data structures that setup pyodide's client-side web assembly and run the two functions ```runGraphStreamingSImulation``` and ```validateGraphSimulation```. The goal of the Flask backend will be to provide a Flask alternative to these Pyodide functions
+
+#### **Miscellaneous Imports** *(irrelevant to backend)*
+There are other imports such as imports that handle console specific settings and actions, constants, type imports, and other 
\ No newline at end of file
diff --git a/static/examples/manifest.json b/static/examples/manifest.json
index a54155ca..542108e5 100644
--- a/static/examples/manifest.json
+++ b/static/examples/manifest.json
@@ -1,11 +1,11 @@
 {
   "files": [
+    "bouncing-ball.json",
+    "cascade-subsystem.json",
     "feedback-system.json",
+    "fmcw-radar.json",
     "pid-subsystem.json",
-    "cascade-subsystem.json",
-    "bouncing-ball.json",
     "thermostat.json",
-    "fmcw-radar.json",
     "vanderpol.json"
   ]
 }

From 60429d32b5898ff4dfa1e58ae3f4546aeaaf04e0 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 11:57:55 -0500
Subject: [PATCH 02/39] Identifying the relevant functions to bring over to
 Flask

---
 src/routes/backend.py | 53 +++++++++++++++++++++++++++++++++++++++++++
 src/routes/summary.md |  2 +-
 2 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/src/routes/backend.py b/src/routes/backend.py
index f8e11fea..296479e9 100644
--- a/src/routes/backend.py
+++ b/src/routes/backend.py
@@ -4,6 +4,12 @@
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 
+'''
+The Flask web server would not be initialized simultaneously with the SvelteKit website since the latter is statically generated,
+rather there would be some type of deployment of this application such that it could receive requests from 
+"https://view.pathsim.org" (which I think is already encapsualted by the "*" in the CORS.resources.options parameter)
+'''
+
 app = Flask(__name__, static_folder="../static", static_url_path="")
 
 if os.getenv("FLASK_ENV") == "production":
@@ -26,6 +32,53 @@
         supports_credentials=True
     )
 
+@app.route("/runGraphStreamingSimulation", options=["POST"])
+def runGraphStreamingSimulation():
+    try:
+        # Not fully implemented yet
+        data = request.get_json()
+        nodes, connections, settingsStore, codeContext, events = data["nodes"], data["connections"], data["settingsStore"], data["codeContext"], data["events"]
+
+        pass
+    except KeyError as e:
+        return jsonify({"success": False, "error": f"Missing key, error: {e}"})
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+
+@app.route("/validateGraphSimulation", options=["POST"])
+def runGraphStreamingSimulation():
+    try:
+        # Not fully implemented yet
+
+        data = request.get_json()
+        nodes, codeContext = data["nodes"], data["codeContext"]
+
+        pass
+    except KeyError as e:
+        return jsonify({"success": False, "error": f"Missing key, error: {e}"})
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+
+# Global error handler to ensure all errors return JSON
+@app.errorhandler(Exception)
+def handle_exception(e):
+    """Global exception handler to ensure JSON responses."""
+    import traceback
+    from werkzeug.exceptions import HTTPException
+
+    error_details = traceback.format_exc()
+    print(f"Unhandled exception: {error_details}")
+
+    # For HTTP exceptions, return a cleaner response
+    if isinstance(e, HTTPException):
+        return jsonify(
+            {"success": False, "error": f"{e.name}: {e.description}"}
+        ), e.code
+
+    # For all other exceptions, return a generic JSON error
+    return jsonify({"success": False, "error": f"Internal server error: {str(e)}"}), 500
+
+
 if __name__ == "__Main__":
     port = int(os.getenv("PORT", 800)) 
     app.run(host="0.0.0.0", port=port, debug=os.getenv("FLASK_ENV") != "production")
\ No newline at end of file
diff --git a/src/routes/summary.md b/src/routes/summary.md
index 925b0fef..c66a94cb 100644
--- a/src/routes/summary.md
+++ b/src/routes/summary.md
@@ -14,7 +14,7 @@ These are the custom UI Components that are rendered on the home page
 From what I can see these stores help organize the data organization of multiple data structures whether that includes core data structures like graphs and events or abitrary. Core to all of this functionality is the Svelte writable 
 
 #### **Pyodide and Python Functionality Imports** *(relevant to backend)*
-These are the functions and data structures that setup pyodide's client-side web assembly and run the two functions ```runGraphStreamingSImulation``` and ```validateGraphSimulation```. The goal of the Flask backend will be to provide a Flask alternative to these Pyodide functions
+These are the functions and data structures that setup pyodide's client-side web assembly and run the two functions ```runGraphStreamingSImulation``` and ```validateGraphSimulation```. The goal of the Flask backend will be to provide a Flask alternative to these Pyodide functions. Some functions from pyodide bridge of particular interest are also ```initPyodide``` and ```continueStreamingSimulation```.
 
 #### **Miscellaneous Imports** *(irrelevant to backend)*
 There are other imports such as imports that handle console specific settings and actions, constants, type imports, and other 
\ No newline at end of file

From faad5ca87add956a28ec128c23bcdf64c82527fb Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 13:16:26 -0500
Subject: [PATCH 03/39] More small changes, picking apart pyodideState and
 simulationState

---
 package.json          |  3 +-
 src/routes/backend.py | 84 -------------------------------------------
 src/routes/summary.md |  8 ++++-
 3 files changed, 9 insertions(+), 86 deletions(-)
 delete mode 100644 src/routes/backend.py

diff --git a/package.json b/package.json
index acf65fa1..047a0eac 100644
--- a/package.json
+++ b/package.json
@@ -15,7 +15,8 @@
     "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
     "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
     "lint": "eslint .",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "start:backend": "python src/backend.py"
   },
   "devDependencies": {
     "@sveltejs/adapter-static": "^3.0.0",
diff --git a/src/routes/backend.py b/src/routes/backend.py
deleted file mode 100644
index 296479e9..00000000
--- a/src/routes/backend.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import os
-import json
-import requests as req
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-
-'''
-The Flask web server would not be initialized simultaneously with the SvelteKit website since the latter is statically generated,
-rather there would be some type of deployment of this application such that it could receive requests from 
-"https://view.pathsim.org" (which I think is already encapsualted by the "*" in the CORS.resources.options parameter)
-'''
-
-app = Flask(__name__, static_folder="../static", static_url_path="")
-
-if os.getenv("FLASK_ENV") == "production":
-    CORS(app,
-         resources={
-             r"/*": {
-                 "origins": ["*"],
-                 "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-                 "allow_headers": ["Content-Type", "Authorization"]
-             } 
-         })
-else:
-    CORS(
-        app, 
-        reosurces={
-            r"/*": {""
-                "origins": {"origins": ["http://localhost:5173", "http://localhost:3000"]}
-            }
-        },
-        supports_credentials=True
-    )
-
-@app.route("/runGraphStreamingSimulation", options=["POST"])
-def runGraphStreamingSimulation():
-    try:
-        # Not fully implemented yet
-        data = request.get_json()
-        nodes, connections, settingsStore, codeContext, events = data["nodes"], data["connections"], data["settingsStore"], data["codeContext"], data["events"]
-
-        pass
-    except KeyError as e:
-        return jsonify({"success": False, "error": f"Missing key, error: {e}"})
-    except Exception as e:
-        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-
-@app.route("/validateGraphSimulation", options=["POST"])
-def runGraphStreamingSimulation():
-    try:
-        # Not fully implemented yet
-
-        data = request.get_json()
-        nodes, codeContext = data["nodes"], data["codeContext"]
-
-        pass
-    except KeyError as e:
-        return jsonify({"success": False, "error": f"Missing key, error: {e}"})
-    except Exception as e:
-        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-
-# Global error handler to ensure all errors return JSON
-@app.errorhandler(Exception)
-def handle_exception(e):
-    """Global exception handler to ensure JSON responses."""
-    import traceback
-    from werkzeug.exceptions import HTTPException
-
-    error_details = traceback.format_exc()
-    print(f"Unhandled exception: {error_details}")
-
-    # For HTTP exceptions, return a cleaner response
-    if isinstance(e, HTTPException):
-        return jsonify(
-            {"success": False, "error": f"{e.name}: {e.description}"}
-        ), e.code
-
-    # For all other exceptions, return a generic JSON error
-    return jsonify({"success": False, "error": f"Internal server error: {str(e)}"}), 500
-
-
-if __name__ == "__Main__":
-    port = int(os.getenv("PORT", 800)) 
-    app.run(host="0.0.0.0", port=port, debug=os.getenv("FLASK_ENV") != "production")
\ No newline at end of file
diff --git a/src/routes/summary.md b/src/routes/summary.md
index c66a94cb..68867b09 100644
--- a/src/routes/summary.md
+++ b/src/routes/summary.md
@@ -14,7 +14,13 @@ These are the custom UI Components that are rendered on the home page
 From what I can see these stores help organize the data organization of multiple data structures whether that includes core data structures like graphs and events or abitrary. Core to all of this functionality is the Svelte writable 
 
 #### **Pyodide and Python Functionality Imports** *(relevant to backend)*
-These are the functions and data structures that setup pyodide's client-side web assembly and run the two functions ```runGraphStreamingSImulation``` and ```validateGraphSimulation```. The goal of the Flask backend will be to provide a Flask alternative to these Pyodide functions. Some functions from pyodide bridge of particular interest are also ```initPyodide``` and ```continueStreamingSimulation```.
+These are the functions and data structures that setup pyodide's client-side web assembly and run the two functions ```runGraphStreamingSImulation``` and ```validateGraphSimulation```. The goal of the Flask backend will be to provide a Flask alternative to these Pyodide functions.
+
+Additionally, some functions imported from lib/pyodide/bridge need to have some clever parallels in the Flask backend infrastructure. That includes these imports:  
+```import { pyodideState, simulationState, initPyodide, stopSimulation, continueStreamingSimulation } from '$lib/pyodide/bridge';```  
+```import { runGraphStreamingSimulation, validateGraphSimulation } from '$lib/pyodide/pathsimRunner';```
+
+I think that a lot of the state handling can be completely removed since we now have the backend running, I just need to try and understand it more. Need to learn how to handle the pyodide and simulation state.
 
 #### **Miscellaneous Imports** *(irrelevant to backend)*
 There are other imports such as imports that handle console specific settings and actions, constants, type imports, and other 
\ No newline at end of file

From 783ab62c4b757173eb1ac8e0a380ef9b80192637 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 13:44:48 -0500
Subject: [PATCH 04/39] Made a backendPreference form with binary values
 pyodide and flask

---
 src/backend.py                      | 105 ++++++++++++++++++++++++++++
 src/lib/stores/backendPreference.ts |  61 ++++++++++++++++
 src/lib/types/index.ts              |   3 +
 src/lib/types/simulation.ts         |   5 +-
 4 files changed, 171 insertions(+), 3 deletions(-)
 create mode 100644 src/backend.py
 create mode 100644 src/lib/stores/backendPreference.ts

diff --git a/src/backend.py b/src/backend.py
new file mode 100644
index 00000000..15453e88
--- /dev/null
+++ b/src/backend.py
@@ -0,0 +1,105 @@
+import os
+import json
+import requests as req
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+'''
+The Flask web server would not be initialized simultaneously with the SvelteKit website since the latter is statically generated,
+rather there would be some type of deployment of this application such that it could receive requests from 
+"https://view.pathsim.org" (which I think is already encapsualted by the "*" in the CORS.resources.options parameter)
+'''
+
+app = Flask(__name__, static_folder="../static", static_url_path="")
+
+if os.getenv("FLASK_ENV") == "production":
+    CORS(app,
+         resources={
+             r"/*": {
+                 "origins": ["*"],
+                 "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+                 "allow_headers": ["Content-Type", "Authorization"]
+             } 
+         })
+else:
+    CORS(
+        app, 
+        reosurces={
+            r"/*": {""
+                "origins": {"origins": ["http://localhost:5173", "http://localhost:3000"]}
+            }
+        },
+        supports_credentials=True
+    )
+
+@app.route("/runGraphStreamingSimulation", options=["POST"])
+def runGraphStreamingSimulation():
+    try:
+        # Not fully implemented yet
+        data = request.get_json()
+        nodes, connections, settingsStore, codeContext, events = data["nodes"], data["connections"], data["settingsStore"], data["codeContext"], data["events"]
+
+        pass
+    except KeyError as e:
+        return jsonify({"success": False, "error": f"Missing key, error: {e}"})
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+
+@app.route("/validateGraphSimulation", options=["POST"])
+def validateGraphSimulationy():
+    try:
+        # Not fully implemented yet
+
+        data = request.get_json()
+        nodes, codeContext = data["nodes"], data["codeContext"]
+
+        pass
+    except KeyError as e:
+        return jsonify({"success": False, "error": f"Missing key, error: {e}"})
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+
+
+# ------------------- STATE DEPENDENT / CHANGING ROUTES ------------------
+
+@app.route("/continueStreamingSimulation", options=["POST"])
+def continueStreamingSimulation():
+    try:
+        # Not fully implemented yet
+
+        data = request.get_json()
+        duration = data["duration"]
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+
+@app.route("/initialize", options=["GET"])
+def initialize():
+    try:
+        # Not fully implemented yet
+        pass
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+    
+# Global error handler to ensure all errors return JSON
+@app.errorhandler(Exception)
+def handle_exception(e):
+    """Global exception handler to ensure JSON responses."""
+    import traceback
+    from werkzeug.exceptions import HTTPException
+
+    error_details = traceback.format_exc()
+    print(f"Unhandled exception: {error_details}")
+
+    # For HTTP exceptions, return a cleaner response
+    if isinstance(e, HTTPException):
+        return jsonify(
+            {"success": False, "error": f"{e.name}: {e.description}"}
+        ), e.code
+
+    # For all other exceptions, return a generic JSON error
+    return jsonify({"success": False, "error": f"Internal server error: {str(e)}"}), 500
+
+
+if __name__ == "__Main__":
+    port = int(os.getenv("PORT", 800)) 
+    app.run(host="0.0.0.0", port=port, debug=os.getenv("FLASK_ENV") != "production")
\ No newline at end of file
diff --git a/src/lib/stores/backendPreference.ts b/src/lib/stores/backendPreference.ts
new file mode 100644
index 00000000..f7889d59
--- /dev/null
+++ b/src/lib/stores/backendPreference.ts
@@ -0,0 +1,61 @@
+/**
+ * Backend Preference store
+ * Manages whether the client prefers to run pathview via Pyodide local WebAssembly or with API calls to a Flask backend
+ * with localStorage persistence
+ */
+
+import { writable } from 'svelte/store';
+import { browser } from '$app/environment';
+
+export type BackendPreference = 'pyodide' | 'flask';
+
+// Get initial backend preference from localStorage or system preference
+function getIntialBackendPreference(): BackendPreference {
+	if (!browser) return 'pyodide';
+
+	const stored = localStorage.getItem('pathview-backend-preference');
+	if (stored === 'pyodide' || stored === 'flask') {
+		return stored;
+	}
+
+	return 'pyodide';
+}
+
+// Create the backend preference store
+const backendPreference = writable<BackendPreference>(getIntialBackendPreference());
+
+// Apply backend preference to document and persist
+backendPreference.subscribe((value) => {
+	if (!browser) return;
+
+	// Persist to localStorage
+	localStorage.setItem('pathview-backend-preference', value);
+});
+
+// Theme store with actions
+export const backendPreferenceStore = {
+	subscribe: backendPreference.subscribe,
+
+	/**
+	 * Toggle between a preference for flask or pyodide
+	 */
+	toggle(): void {
+		backendPreference.update((current) => (current === 'pyodide' ? 'flask' : 'pyodide'));
+	},
+
+	/**
+	 * Set specific preference
+	 */
+	set(newPreference: BackendPreference): void {
+		backendPreference.set(newPreference);
+	},
+
+	/**
+	 * Get current preference value
+	 */
+	get(): BackendPreference {
+		let current: BackendPreference = 'pyodide';
+		backendPreference.subscribe((value) => (current = value))();
+		return current;
+	}
+};
diff --git a/src/lib/types/index.ts b/src/lib/types/index.ts
index e7cb7072..c70b31f0 100644
--- a/src/lib/types/index.ts
+++ b/src/lib/types/index.ts
@@ -84,3 +84,6 @@ export type {
 	ModelContent
 } from './component';
 export { COMPONENT_EXTENSIONS, COMPONENT_MIME_TYPES, ALL_COMPONENT_EXTENSIONS } from './component';
+
+// Backend Preference type
+export type BackendPreference = 'pyodide' | 'flask';
diff --git a/src/lib/types/simulation.ts b/src/lib/types/simulation.ts
index 8ba121d7..1d134618 100644
--- a/src/lib/types/simulation.ts
+++ b/src/lib/types/simulation.ts
@@ -57,8 +57,7 @@ export interface SimulationSettings {
 	ftol: string; // Fixed-point iteration tolerance (Python expression)
 	dt_min: string; // Minimum timestep for adaptive solvers (Python expression)
 	dt_max: string; // Maximum timestep for adaptive solvers (Python expression)
-	ghostTraces: number; // Number of previous runs to show as ghost traces (0-6)
-	plotResults: boolean; // UI: auto-open plot panel
+	ghostTraces: number; // Number of previous runs to show as ghost traces
 }
 
 /** Worker message types */
@@ -91,4 +90,4 @@ export interface SimulationState {
 	error: string | null;
 	result: SimulationResult | null;
 	resultHistory: SimulationResult[];
-}
+}
\ No newline at end of file

From 237c52a13b52124f8031ba3df04dc483a6040a9c Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 13:58:16 -0500
Subject: [PATCH 05/39] Adding the Pyodide and Flask toggle button to the main
 page (still haven't implemented nay backend changes), also added backendpref
 store and structure

---
 src/lib/stores/index.ts |  1 +
 src/routes/+page.svelte | 17 +++++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/src/lib/stores/index.ts b/src/lib/stores/index.ts
index 74f1a2f1..2a5a19fb 100644
--- a/src/lib/stores/index.ts
+++ b/src/lib/stores/index.ts
@@ -7,6 +7,7 @@ export { graphStore } from './graph';
 export { eventStore } from './events';
 export { settingsStore } from './settings';
 export { themeStore } from './theme';
+export { backendPreferenceStore } from './backendPreference'
 export { consoleStore } from './console';
 export { codeContextStore } from './codeContext';
 
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 52f7f087..e945229b 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -36,6 +36,7 @@
 	import { settingsStore } from '$lib/stores/settings';
 	import { codeContextStore } from '$lib/stores/codeContext';
 	import { themeStore, type Theme } from '$lib/stores/theme';
+	import { backendPreferenceStore, type BackendPreference } from '$lib/stores/backendPreference';
 	import { contextMenuStore, type ContextMenuTarget } from '$lib/stores/contextMenu';
 	import { consoleStore } from '$lib/stores/console';
 	import { nodeUpdatesStore } from '$lib/stores/nodeUpdates';
@@ -348,6 +349,7 @@
 	let hasRunSimulation = $state(false);
 	let statusText = $state('Ready');
 	let currentTheme = $state<Theme>('dark');
+	let currentBackendPreference = $state<BackendPreference>('pyodide');
 	let consoleLogCount = $state(0);
 	let plotActiveTab = $state(0);
 	let plotViewMode = $state<'tabs' | 'tiles'>('tabs');
@@ -373,6 +375,11 @@
 			currentTheme = theme;
 		});
 
+		const unsubBackendPreference = backendPreferenceStore.subscribe((backendPreference) => {
+			console.log("Unsubscribing from the backend preference store")
+			currentBackendPreference = backendPreference
+		})
+
 		const unsubNodeCount = graphStore.nodesArray.subscribe((nodes) => {
 			nodeCount = nodes.length;
 		});
@@ -455,6 +462,7 @@
 			unsubPinnedPreviews();
 			unsubContextMenu();
 			unsubTheme();
+			unsubBackendPreference();
 			unsubNodeCount();
 			unsubPyodide();
 			unsubSimulation();
@@ -977,6 +985,15 @@
 			>
 				<Icon name="terminal" size={18} />
 			</button>
+			<button
+				class="toggle-btn"
+				onclick={() => backendPreferenceStore.toggle()}
+				use:tooltip={{ text: currentBackendPreference === 'pyodide' ? 'You are using Pyodide Web Assembly' : 'You are using a Flask Web Server', shortcut: "T", position: "right" }}
+				aria-label="Toggle your backend preference"
+			>
+				Bruh
+				<!-- <Icon name={currentTheme === 'dark' ? 'sun' : 'moon'} size={18} /> -->
+			</button>
 		</div>
 
 		<!-- Simulation settings -->

From 4155bc6faace5fde09523f5abf11903719c349f0 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 14:07:01 -0500
Subject: [PATCH 06/39] Added the icions that help you distinguish between you
 backend preference

---
 src/lib/components/icons/Icon.svelte | 9 +++++++++
 src/routes/+page.svelte              | 3 +--
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/lib/components/icons/Icon.svelte b/src/lib/components/icons/Icon.svelte
index cb6a2088..bbdafe99 100644
--- a/src/lib/components/icons/Icon.svelte
+++ b/src/lib/components/icons/Icon.svelte
@@ -380,6 +380,15 @@
 		<circle cx="8.5" cy="8.5" r="1.5"/>
 		<polyline points="21 15 16 10 5 21"/>
 	</svg>
+{:else if name === "server"}
+	<svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+	<g fill="none" stroke="currentColor" stroke-width="1.5"><path d="M2 17c0-1.886 0-2.828.586-3.414S4.114 13 6 13h12c1.886 0 2.828 0 3.414.586S22 15.114 22 17s0 2.828-.586 3.414S19.886 21 18 21H6c-1.886 0-2.828 0-3.414-.586S2 18.886 2 17ZM2 6c0-1.886 0-2.828.586-3.414S4.114 2 6 2h12c1.886 0 2.828 0 3.414.586S22 4.114 22 6s0 2.828-.586 3.414S19.886 10 18 10H6c-1.886 0-2.828 0-3.414-.586S2 7.886 2 6Z"/><path stroke-linecap="round" d="M11 6h7M6 6h2m3 11h7M6 17h2"/></g>
+	</svg>
+{:else if name == "laptop"}
+	<svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+		<g>
+		<path stroke="currentColor" stroke-linecap="round" stroke-width="1.5" d="M19.647 15.536H4.353m15.294 0V8c0-1.886 0-2.828-.586-3.414C18.476 4 17.533 4 15.647 4H8.353c-1.886 0-2.828 0-3.414.586S4.353 6.114 4.353 8v7.536m15.294 0l1.744 1.8l.088.092a2 2 0 0 1 .52 1.284l.001.127c0 .15 0 .224-.004.287a2 2 0 0 1-1.87 1.87a5 5 0 0 1-.287.004H4.161c-.15 0-.224 0-.287-.004a2 2 0 0 1-1.87-1.87C2 19.063 2 18.988 2 18.84l.001-.127a2 2 0 0 1 .52-1.284l.088-.092l1.744-1.8M9.5 18.5h5"/><path fill="currentColor" d="M12.75 6.75a.75.75 0 1 1-1.5 0a.75.75 0 0 1 1.5 0"/></g>
+	</svg>
 {:else}
 	<span class="text-icon">{name}</span>
 {/if}
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index e945229b..c331c70b 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -991,8 +991,7 @@
 				use:tooltip={{ text: currentBackendPreference === 'pyodide' ? 'You are using Pyodide Web Assembly' : 'You are using a Flask Web Server', shortcut: "T", position: "right" }}
 				aria-label="Toggle your backend preference"
 			>
-				Bruh
-				<!-- <Icon name={currentTheme === 'dark' ? 'sun' : 'moon'} size={18} /> -->
+				<Icon name={currentBackendPreference === 'pyodide' ? 'laptop' : 'server'} size={18} />
 			</button>
 		</div>
 

From 90ddba627d1988c7d0954c556e1ca9ccb50b930a Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 14:37:29 -0500
Subject: [PATCH 07/39] Added backend preference as a keyboard shortcut to
 toggle, added to keyboard shortcuts, currently working on modifying handleRun
 and handleContinue

---
 package.json                                  |   3 +-
 .../dialogs/KeyboardShortcutsDialog.svelte    |   7 +-
 src/routes/+page.svelte                       | 169 ++++++++++--------
 3 files changed, 105 insertions(+), 74 deletions(-)

diff --git a/package.json b/package.json
index 047a0eac..c2c10495 100644
--- a/package.json
+++ b/package.json
@@ -16,7 +16,8 @@
     "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
     "lint": "eslint .",
     "format": "prettier --write .",
-    "start:backend": "python src/backend.py"
+    "start:backend": "python src/backend.py",
+    "start:both": "concurrently \"npm run dev\" \"npm run start:backend\""
   },
   "devDependencies": {
     "@sveltejs/adapter-static": "^3.0.0",
diff --git a/src/lib/components/dialogs/KeyboardShortcutsDialog.svelte b/src/lib/components/dialogs/KeyboardShortcutsDialog.svelte
index be3eb955..29fb13e9 100644
--- a/src/lib/components/dialogs/KeyboardShortcutsDialog.svelte
+++ b/src/lib/components/dialogs/KeyboardShortcutsDialog.svelte
@@ -58,7 +58,7 @@
 				{ keys: ['H'], description: 'Go to root' },
 				{ keys: ['+'], description: 'Zoom in' },
 				{ keys: ['-'], description: 'Zoom out' },
-				{ keys: ['T'], description: 'Theme' }
+				{ keys: ['T'], description: 'Theme' },
 			]
 		},
 		{
@@ -70,7 +70,7 @@
 				{ keys: ['E'], description: 'Editor' },
 				{ keys: ['V'], description: 'Results' },
 				{ keys: ['C'], description: 'Console' },
-				{ keys: ['P'], description: 'Pin plots' }
+				{ keys: ['P'], description: 'Pin plots' },
 			]
 		},
 		{
@@ -78,7 +78,8 @@
 			items: [
 				{ keys: ['Ctrl', 'Enter'], description: 'Simulate' },
 				{ keys: ['Shift', 'Enter'], description: 'Continue' },
-				{ keys: ['?'], description: 'Shortcuts' }
+				{ keys: ['?'], description: 'Shortcuts' },
+				{ keys: ['Q'], description: 'Toggle Backend Preference'},
 			]
 		}
 	];
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index c331c70b..ae67a647 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -341,8 +341,24 @@
 
 	// App state
 	let nodeCount = $state(0);
+
+	// ---- Pyodide Handling : START ----
 	let pyodideReady = $state(false);
 	let pyodideLoading = $state(false);
+	// ---- Pyodide Handling : END ----
+
+	let backendLoading = $derived.by(()=>{
+		switch (backendPreferenceStore.get()) {
+			case "pyodide":
+				return pyodideLoading
+			case "flask":
+				// We'll assume that the flask backend is always running, and we'll just handle errors as appropriate
+				return false
+			default:
+				return pyodideLoading
+		}
+	}) // Determine the loading state based on whichever backend preference is currently active
+
 	let simRunning = $state(false);
 	let isRunStarting = false; // Synchronous flag to prevent race conditions
 	let isContinuing = false; // Synchronous flag to prevent rapid continue calls
@@ -633,6 +649,10 @@
 					event.preventDefault();
 					themeStore.toggle();
 					return;
+				case 'q':
+					event.preventDefault();
+					backendPreferenceStore.toggle();
+					return;
 				case '+':
 				case '=':
 					if (!event.ctrlKey && !event.metaKey) {
@@ -685,88 +705,97 @@
 
 	// Run simulation (auto-initializes if needed)
 	async function handleRun() {
-		// Prevent concurrent simulation runs (synchronous check for rapid key presses)
-		if (simRunning || isRunStarting || pyodideLoading) return;
-
-		// Auto-initialize if not ready
-		if (!pyodideReady) {
-			try {
-				await initPyodide();
-			} catch (error) {
-				console.error('Failed to initialize Pyodide:', error);
-				return;
-			}
-		}
-
-		// Set flag synchronously to prevent race conditions during validation
-		isRunStarting = true;
-
-		try {
-			// Run simulation
-			const { nodes, connections } = graphStore.toJSON();
-			if (nodes.length === 0) {
-				statusText = 'Add nodes first';
-				return;
-			}
-
-			// Auto-open console on first run to show progress
-			if (!hasAutoOpenedConsole) {
-				showConsole = true;
-				hasAutoOpenedConsole = true;
+		// Logging the current backend preference
+		console.log(`The current backend preference is ${currentBackendPreference}`)
+
+		if(currentBackendPreference == "pyodide") {
+			// Prevent concurrent simulation runs (synchronous check for rapid key presses)
+			if (simRunning || isRunStarting || pyodideLoading) return;
+
+			// Auto-initialize if not ready
+			if (!pyodideReady) {
+				try {
+					await initPyodide();
+				} catch (error) {
+					console.error('Failed to initialize Pyodide:', error);
+					return;
+				}
 			}
 
-			const codeContext = codeContextStore.getCode();
+			// Set flag synchronously to prevent race conditions during validation
+			isRunStarting = true;
 
-			// Validate before running
 			try {
-				statusText = 'Validating...';
-				const validation = await validateGraphSimulation(nodes, codeContext);
+				// Run simulation
+				const { nodes, connections } = graphStore.toJSON();
+				if (nodes.length === 0) {
+					statusText = 'Add nodes first';
+					return;
+				}
 
-				if (!validation.valid) {
-					// Show validation errors
+				// Auto-open console on first run to show progress
+				if (!hasAutoOpenedConsole) {
 					showConsole = true;
-					consoleStore.error('Validation failed:');
-					for (const err of validation.errors) {
-						if (err.nodeId === '__code_context__') {
-							consoleStore.error(`  Code context: ${err.error}`);
-						} else {
-							const node = nodes.find((n) => n.id === err.nodeId);
-							const nodeName = node?.name || err.nodeId;
-							consoleStore.error(`  ${nodeName}.${err.param}: ${err.error}`);
+					hasAutoOpenedConsole = true;
+				}
+
+				const codeContext = codeContextStore.getCode();
+
+				// Validate before running
+				try {
+					statusText = 'Validating...';
+					const validation = await validateGraphSimulation(nodes, codeContext);
+
+					if (!validation.valid) {
+						// Show validation errors
+						showConsole = true;
+						consoleStore.error('Validation failed:');
+						for (const err of validation.errors) {
+							if (err.nodeId === '__code_context__') {
+								consoleStore.error(`  Code context: ${err.error}`);
+							} else {
+								const node = nodes.find((n) => n.id === err.nodeId);
+								const nodeName = node?.name || err.nodeId;
+								consoleStore.error(`  ${nodeName}.${err.param}: ${err.error}`);
+							}
 						}
+						statusText = 'Validation failed';
+						return;
 					}
-					statusText = 'Validation failed';
+				} catch (error) {
+					showConsole = true;
+					consoleStore.error(`Validation error: ${error}`);
+					statusText = 'Validation error';
 					return;
 				}
-			} catch (error) {
-				showConsole = true;
-				consoleStore.error(`Validation error: ${error}`);
-				statusText = 'Validation error';
-				return;
-			}
 
-			// Run streaming simulation
-			try {
-				const events = eventStore.toJSON();
-				await runGraphStreamingSimulation(
-					nodes,
-					connections,
-					settingsStore.get(),
-					codeContext,
-					events
-				);
-				// Auto-open results panel only on first run
-				if (!hasAutoOpenedPlot) {
-					showPlot = true;
-					hasAutoOpenedPlot = true;
+				// Run streaming simulation
+				try {
+					const events = eventStore.toJSON();
+					await runGraphStreamingSimulation(
+						nodes,
+						connections,
+						settingsStore.get(),
+						codeContext,
+						events
+					);
+					// Auto-open results panel only on first run
+					if (!hasAutoOpenedPlot) {
+						showPlot = true;
+						hasAutoOpenedPlot = true;
+					}
+				} catch (error) {
+					// Auto-open console panel to show error details
+					showConsole = true;
+					console.error('Simulation failed:', error);
 				}
-			} catch (error) {
-				// Auto-open console panel to show error details
-				showConsole = true;
-				console.error('Simulation failed:', error);
+			} finally {
+				isRunStarting = false;
 			}
-		} finally {
-			isRunStarting = false;
+		} else if(currentBackendPreference == "flask") {
+			setTimeout(() => {
+				
+			}, timeout);
 		}
 	}
 
@@ -988,7 +1017,7 @@
 			<button
 				class="toggle-btn"
 				onclick={() => backendPreferenceStore.toggle()}
-				use:tooltip={{ text: currentBackendPreference === 'pyodide' ? 'You are using Pyodide Web Assembly' : 'You are using a Flask Web Server', shortcut: "T", position: "right" }}
+				use:tooltip={{ text: currentBackendPreference === 'pyodide' ? 'You are using Pyodide Web Assembly' : 'You are using a Flask Web Server', shortcut: "Q", position: "right" }}
 				aria-label="Toggle your backend preference"
 			>
 				<Icon name={currentBackendPreference === 'pyodide' ? 'laptop' : 'server'} size={18} />

From b14270eed1b253cbb7abc0cbec382f71f55a082b Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 15:20:40 -0500
Subject: [PATCH 08/39] Beginning to work on the validation Flask api route,
 trying to figure out what other data structures (like nodeRegistry and some
 of the python generation code) I need to convert

---
 package-lock.json       |  13 +++
 package.json            |   1 +
 src/backend.py          |  24 ++++--
 src/routes/+page.svelte | 174 +++++++++++++++++++++++-----------------
 4 files changed, 131 insertions(+), 81 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 5ea53ba9..2574ae03 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12,6 +12,7 @@
         "@codemirror/theme-one-dark": "^6.0.0",
         "@xyflow/svelte": "^1.5.0",
         "codemirror": "^6.0.0",
+        "dotenv": "^17.2.3",
         "katex": "^0.16.0",
         "plotly.js-dist-min": "^2.35.0",
         "pyodide": "^0.26.0"
@@ -1802,6 +1803,18 @@
       "integrity": "sha512-jDwizj+IlEZBunHcOuuFVBnIMPAEHvTsJj0BcIp94xYguLRVBcXO853px/MyIJvbVzWdsGvrRweIUWJw8hBP7A==",
       "license": "MIT"
     },
+    "node_modules/dotenv": {
+      "version": "17.2.3",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.2.3.tgz",
+      "integrity": "sha512-JVUnt+DUIzu87TABbhPmNfVdBDt18BLOWjMUFJMSi/Qqg7NTYtabbvSNJGOJ7afbRuv9D/lngizHtP7QyLQ+9w==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
     "node_modules/esbuild": {
       "version": "0.27.2",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz",
diff --git a/package.json b/package.json
index c2c10495..0135546a 100644
--- a/package.json
+++ b/package.json
@@ -39,6 +39,7 @@
     "@codemirror/theme-one-dark": "^6.0.0",
     "@xyflow/svelte": "^1.5.0",
     "codemirror": "^6.0.0",
+    "dotenv": "^17.2.3",
     "katex": "^0.16.0",
     "plotly.js-dist-min": "^2.35.0",
     "pyodide": "^0.26.0"
diff --git a/src/backend.py b/src/backend.py
index 15453e88..8f79635b 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -32,7 +32,7 @@
         supports_credentials=True
     )
 
-@app.route("/runGraphStreamingSimulation", options=["POST"])
+@app.route("/runGraphStreamingSimulation", methods=["POST"])
 def runGraphStreamingSimulation():
     try:
         # Not fully implemented yet
@@ -45,14 +45,22 @@ def runGraphStreamingSimulation():
     except Exception as e:
         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
 
-@app.route("/validateGraphSimulation", options=["POST"])
-def validateGraphSimulationy():
+@app.route("/validateGraphSimulation", methods=["POST"])
+def validateGraphSimulation():
+    print("Received a request at /validateGraphSimulation")
+
     try:
         # Not fully implemented yet
+        # - Need access to node registry for node params
 
         data = request.get_json()
+        print("Received the data....")
         nodes, codeContext = data["nodes"], data["codeContext"]
-
+        print("The nodes data produced was: ", nodes)
+        return jsonify({"success": True, data: {
+            "valid": False,
+            "errors": []
+        }})
         pass
     except KeyError as e:
         return jsonify({"success": False, "error": f"Missing key, error: {e}"})
@@ -62,7 +70,7 @@ def validateGraphSimulationy():
 
 # ------------------- STATE DEPENDENT / CHANGING ROUTES ------------------
 
-@app.route("/continueStreamingSimulation", options=["POST"])
+@app.route("/continueStreamingSimulation", methods=["POST"])
 def continueStreamingSimulation():
     try:
         # Not fully implemented yet
@@ -72,7 +80,7 @@ def continueStreamingSimulation():
     except Exception as e:
         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
 
-@app.route("/initialize", options=["GET"])
+@app.route("/initialize", methods=["GET"])
 def initialize():
     try:
         # Not fully implemented yet
@@ -100,6 +108,6 @@ def handle_exception(e):
     return jsonify({"success": False, "error": f"Internal server error: {str(e)}"}), 500
 
 
-if __name__ == "__Main__":
-    port = int(os.getenv("PORT", 800)) 
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 8000)) 
     app.run(host="0.0.0.0", port=port, debug=os.getenv("FLASK_ENV") != "production")
\ No newline at end of file
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index ae67a647..f9992077 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -61,6 +61,8 @@
 	// Console Specific Settings and Actions
 	import { newGraph, openFile, saveFile, saveAsFile, setupAutoSave, clearAutoSave, debouncedAutoSave, loadGraphFromUrl, currentFileName } from '$lib/schema/fileOps';
 	import { triggerFitView, triggerZoomIn, triggerZoomOut, triggerPan, getViewportCenter, screenToFlow, triggerClearSelection, triggerNudge, hasAnySelection, setFitViewPadding } from '$lib/stores/viewActions';
+  import { getFlaskBackendUrl } from '$lib/utils/flaskRoutes';
+  import type { ValidationResult } from '$lib/types';
 
 	// --------------------------- ROOT PAGE IMPORTS | END ---------------------------
 
@@ -703,103 +705,129 @@
 		}
 	}
 
-	// Run simulation (auto-initializes if needed)
+	// Run simulation (auto-initializes if needed) - Interacts with "backend"
 	async function handleRun() {
 		// Logging the current backend preference
 		console.log(`The current backend preference is ${currentBackendPreference}`)
 
-		if(currentBackendPreference == "pyodide") {
+		let usingPyodide = currentBackendPreference == "pyodide"
+
+		if(usingPyodide) {
 			// Prevent concurrent simulation runs (synchronous check for rapid key presses)
 			if (simRunning || isRunStarting || pyodideLoading) return;
 
-			// Auto-initialize if not ready
-			if (!pyodideReady) {
-				try {
-					await initPyodide();
-				} catch (error) {
-					console.error('Failed to initialize Pyodide:', error);
-					return;
-				}
+		} else {
+			// [Since we are working with flask, we just remove the pyodideLoading requirement]
+			if (simRunning || isRunStarting) return;
+		}
+
+
+		// Auto-initialize if not ready
+		if (!pyodideReady && usingPyodide) {
+			try {
+				await initPyodide();
+			} catch (error) {
+				console.error('Failed to initialize Pyodide:', error);
+				return;
 			}
+		}
 
-			// Set flag synchronously to prevent race conditions during validation
-			isRunStarting = true;
+		// Set flag synchronously to prevent race conditions during validation
+		isRunStarting = true;
+
+		try {
+			// Run simulation
+			const { nodes, connections } = graphStore.toJSON();
+			if (nodes.length === 0) {
+				statusText = 'Add nodes first';
+				return;
+			}
+
+			// Auto-open console on first run to show progress
+			if (!hasAutoOpenedConsole) {
+				showConsole = true;
+				hasAutoOpenedConsole = true;
+			}
 
+			const codeContext = codeContextStore.getCode();
+
+			// TODO: Add Flask Parallel
+			// Validate before running
 			try {
-				// Run simulation
-				const { nodes, connections } = graphStore.toJSON();
-				if (nodes.length === 0) {
-					statusText = 'Add nodes first';
-					return;
+				statusText = 'Validating...';
+
+				let validation
+
+				if(usingPyodide) {
+					validation = await validateGraphSimulation(nodes, codeContext);
+				} else {
+					let fetchedData = await fetch(getFlaskBackendUrl()+"/validateGraphSimulation", {
+						method: "POST",
+						body: JSON.stringify({
+							nodes,
+							codeContext
+						}),
+						headers: {
+							"Content-Type":"application/json"
+						}
+					}).then(res => res.json())
+					if(!fetchedData.success) {
+						throw Error(fetchedData.error)
+					} else {
+						validation = fetchedData.data satisfies ValidationResult
+					}
 				}
 
-				// Auto-open console on first run to show progress
-				if (!hasAutoOpenedConsole) {
+				if (!validation.valid) {
+					// Show validation errors
 					showConsole = true;
-					hasAutoOpenedConsole = true;
-				}
-
-				const codeContext = codeContextStore.getCode();
-
-				// Validate before running
-				try {
-					statusText = 'Validating...';
-					const validation = await validateGraphSimulation(nodes, codeContext);
-
-					if (!validation.valid) {
-						// Show validation errors
-						showConsole = true;
-						consoleStore.error('Validation failed:');
-						for (const err of validation.errors) {
-							if (err.nodeId === '__code_context__') {
-								consoleStore.error(`  Code context: ${err.error}`);
-							} else {
-								const node = nodes.find((n) => n.id === err.nodeId);
-								const nodeName = node?.name || err.nodeId;
-								consoleStore.error(`  ${nodeName}.${err.param}: ${err.error}`);
-							}
+					consoleStore.error('Validation failed:');
+					for (const err of validation.errors) {
+						if (err.nodeId === '__code_context__') {
+							consoleStore.error(`  Code context: ${err.error}`);
+						} else {
+							const node = nodes.find((n) => n.id === err.nodeId);
+							const nodeName = node?.name || err.nodeId;
+							consoleStore.error(`  ${nodeName}.${err.param}: ${err.error}`);
 						}
-						statusText = 'Validation failed';
-						return;
 					}
-				} catch (error) {
-					showConsole = true;
-					consoleStore.error(`Validation error: ${error}`);
-					statusText = 'Validation error';
+					statusText = 'Validation failed';
 					return;
 				}
+			} catch (error) {
+				showConsole = true;
+				consoleStore.error(`Validation error: ${error}`);
+				statusText = 'Validation error';
+				return;
+			}
 
-				// Run streaming simulation
-				try {
-					const events = eventStore.toJSON();
-					await runGraphStreamingSimulation(
-						nodes,
-						connections,
-						settingsStore.get(),
-						codeContext,
-						events
-					);
-					// Auto-open results panel only on first run
-					if (!hasAutoOpenedPlot) {
-						showPlot = true;
-						hasAutoOpenedPlot = true;
-					}
-				} catch (error) {
-					// Auto-open console panel to show error details
-					showConsole = true;
-					console.error('Simulation failed:', error);
+			// TODO: Add Flask Parallel
+			// Run streaming simulation
+			try {
+				const events = eventStore.toJSON();
+				await runGraphStreamingSimulation(
+					nodes,
+					connections,
+					settingsStore.get(),
+					codeContext,
+					events
+				);
+				// Auto-open results panel only on first run
+				if (!hasAutoOpenedPlot) {
+					showPlot = true;
+					hasAutoOpenedPlot = true;
 				}
-			} finally {
-				isRunStarting = false;
+			} catch (error) {
+				// Auto-open console panel to show error details
+				showConsole = true;
+				console.error('Simulation failed:', error);
 			}
-		} else if(currentBackendPreference == "flask") {
-			setTimeout(() => {
-				
-			}, timeout);
+		} finally {
+			isRunStarting = false;
 		}
 	}
 
-	// Continue simulation from where it left off (streaming)
+	// Continue simulation from where it left off (streaming) - Interacts with "backend"
 	async function handleContinue() {
 		// Prevent concurrent continue calls (synchronous check for rapid key presses)
 		if (!pyodideReady || !hasRunSimulation || simRunning || isContinuing) return;

From 7683901836b5d8ce1175935bb9de972a9df224a2 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 15:20:52 -0500
Subject: [PATCH 09/39] Adding any files I forgot

---
 src/lib/utils/flaskRoutes.ts | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 src/lib/utils/flaskRoutes.ts

diff --git a/src/lib/utils/flaskRoutes.ts b/src/lib/utils/flaskRoutes.ts
new file mode 100644
index 00000000..66f08095
--- /dev/null
+++ b/src/lib/utils/flaskRoutes.ts
@@ -0,0 +1,5 @@
+import process from "process"
+
+export function getFlaskBackendUrl() {
+    return process.env.FLASK_ENV == "production" ? process.env.FLASK_SERVER_URL : "http://localhost:8000"
+}
\ No newline at end of file

From 1a2843b7ef8ec9e6e173c2c8e92cf8b4105d5a3a Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 15:49:38 -0500
Subject: [PATCH 10/39] More progress on the validateGraphSimulation route,
 trying to figure out how to replicate the validateGraphBridge() functionality

---
 src/backend.py                   | 20 ++++++++++++++------
 src/lib/pyodide/pathsimRunner.ts |  1 +
 src/lib/utils/flaskRoutes.ts     |  5 +++--
 src/routes/+page.svelte          |  5 ++++-
 4 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 8f79635b..1fd7b98e 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -37,7 +37,7 @@ def runGraphStreamingSimulation():
     try:
         # Not fully implemented yet
         data = request.get_json()
-        nodes, connections, settingsStore, codeContext, events = data["nodes"], data["connections"], data["settingsStore"], data["codeContext"], data["events"]
+        nodes, connections, settings_store, code_context, events = data["nodes"], data["connections"], data["settingsStore"], data["codeContext"], data["events"]
 
         pass
     except KeyError as e:
@@ -51,13 +51,21 @@ def validateGraphSimulation():
 
     try:
         # Not fully implemented yet
-        # - Need access to node registry for node params
+        # - We are going to have to recreate nodeRegistry functionality when given the 
+        # - The original validation program has extractParams() and validateGraphBridge() run
+        # - extractParams() uses primarily nodeRegistry functionality
+        # - validateGraphBridge() uses a bunch of generated Python code to run in Pyodide s.t. we can just run it here
 
         data = request.get_json()
-        print("Received the data....")
-        nodes, codeContext = data["nodes"], data["codeContext"]
-        print("The nodes data produced was: ", nodes)
-        return jsonify({"success": True, data: {
+        nodes, code_context, node_registry_nodes = data.get("nodes"), data.get("codeContext"), data.get("nodeRegistryNodes")
+
+        # Extract Node Params
+
+
+        # Validate Graph Bridge
+
+        
+        return jsonify({"success": True, "data": {
             "valid": False,
             "errors": []
         }})
diff --git a/src/lib/pyodide/pathsimRunner.ts b/src/lib/pyodide/pathsimRunner.ts
index 2e12cb7f..0cf446c5 100644
--- a/src/lib/pyodide/pathsimRunner.ts
+++ b/src/lib/pyodide/pathsimRunner.ts
@@ -1035,6 +1035,7 @@ function extractNodeParams(nodes: NodeInstance[]): Record<string, Record<string,
 	const result: Record<string, Record<string, string>> = {};
 
 	for (const node of nodes) {
+		console.log("The node registry is: ", nodeRegistry)
 		const typeDef = nodeRegistry.get(node.type);
 		if (!typeDef) continue;
 
diff --git a/src/lib/utils/flaskRoutes.ts b/src/lib/utils/flaskRoutes.ts
index 66f08095..e05f09d3 100644
--- a/src/lib/utils/flaskRoutes.ts
+++ b/src/lib/utils/flaskRoutes.ts
@@ -1,5 +1,6 @@
-import process from "process"
+// import process from "process"
 
 export function getFlaskBackendUrl() {
-    return process.env.FLASK_ENV == "production" ? process.env.FLASK_SERVER_URL : "http://localhost:8000"
+    // Right now it is this local address, but when we set up the server I'll make it that permanent address
+    return "http://localhost:8000" 
 }
\ No newline at end of file
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index f9992077..b70bd274 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -709,6 +709,7 @@
 	async function handleRun() {
 		// Logging the current backend preference
 		console.log(`The current backend preference is ${currentBackendPreference}`)
+		console.log("The current node registry that the front-end recognizes is: ", nodeRegistry)
 
 		let usingPyodide = currentBackendPreference == "pyodide"
 
@@ -761,11 +762,13 @@
 				if(usingPyodide) {
 					validation = await validateGraphSimulation(nodes, codeContext);
 				} else {
+					console.log("[Sending to Flask web server] The node registry is: ", nodeRegistry.getAll())
 					let fetchedData = await fetch(getFlaskBackendUrl()+"/validateGraphSimulation", {
 						method: "POST",
 						body: JSON.stringify({
 							nodes,
-							codeContext
+							codeContext,
+							nodeRegistryNodes: nodeRegistry.getAll() // It is necessary to pass in the node registry to the backend since it doesn't have it
 						}),
 						headers: {
 							"Content-Type":"application/json"

From fe3757b96d18b50776b8d59dbbd54b9a9c60d55e Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 14 Jan 2026 16:23:03 -0500
Subject: [PATCH 11/39] Clarified with Remi, how to approach the backend
 functionality. Can simply redirect pyodide execution requests to the web
 server!

---
 src/backend.py                            | 126 ++++++++++++----------
 src/lib/pyodide/backend/pyodide/worker.ts |   3 +
 src/routes/+page.svelte                   |  40 +++----
 3 files changed, 90 insertions(+), 79 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 1fd7b98e..36cfdeab 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -31,70 +31,78 @@
         },
         supports_credentials=True
     )
-
-@app.route("/runGraphStreamingSimulation", methods=["POST"])
-def runGraphStreamingSimulation():
+@app.route("/execute", methods=["POST"])
+def executeCode():
     try:
-        # Not fully implemented yet
-        data = request.get_json()
-        nodes, connections, settings_store, code_context, events = data["nodes"], data["connections"], data["settingsStore"], data["codeContext"], data["events"]
-
+        return jsonify({"success": True, "message": "Hello there"})
         pass
-    except KeyError as e:
-        return jsonify({"success": False, "error": f"Missing key, error: {e}"})
     except Exception as e:
         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-
-@app.route("/validateGraphSimulation", methods=["POST"])
-def validateGraphSimulation():
-    print("Received a request at /validateGraphSimulation")
-
-    try:
-        # Not fully implemented yet
-        # - We are going to have to recreate nodeRegistry functionality when given the 
-        # - The original validation program has extractParams() and validateGraphBridge() run
-        # - extractParams() uses primarily nodeRegistry functionality
-        # - validateGraphBridge() uses a bunch of generated Python code to run in Pyodide s.t. we can just run it here
-
-        data = request.get_json()
-        nodes, code_context, node_registry_nodes = data.get("nodes"), data.get("codeContext"), data.get("nodeRegistryNodes")
-
-        # Extract Node Params
-
-
-        # Validate Graph Bridge
-
         
-        return jsonify({"success": True, "data": {
-            "valid": False,
-            "errors": []
-        }})
-        pass
-    except KeyError as e:
-        return jsonify({"success": False, "error": f"Missing key, error: {e}"})
-    except Exception as e:
-        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-
-
-# ------------------- STATE DEPENDENT / CHANGING ROUTES ------------------
-
-@app.route("/continueStreamingSimulation", methods=["POST"])
-def continueStreamingSimulation():
-    try:
-        # Not fully implemented yet
-
-        data = request.get_json()
-        duration = data["duration"]
-    except Exception as e:
-        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-
-@app.route("/initialize", methods=["GET"])
-def initialize():
-    try:
-        # Not fully implemented yet
-        pass
-    except Exception as e:
-        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+# @app.route("/runGraphStreamingSimulation", methods=["POST"])
+# def runGraphStreamingSimulation():
+#     try:
+#         # Not fully implemented yet
+#         data = request.get_json()
+#         nodes, connections, settings_store, code_context, events = data["nodes"], data["connections"], data["settingsStore"], data["codeContext"], data["events"]
+
+#         pass
+#     except KeyError as e:
+#         return jsonify({"success": False, "error": f"Missing key, error: {e}"})
+#     except Exception as e:
+#         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+
+# @app.route("/validateGraphSimulation", methods=["POST"])
+# def validateGraphSimulation():
+#     print("Received a request at /validateGraphSimulation")
+
+#     try:
+#         # Not fully implemented yet
+#         # - We are going to have to recreate nodeRegistry functionality when given the 
+#         # - The original validation program has extractParams() and validateGraphBridge() run
+#         # - extractParams() uses primarily nodeRegistry functionality
+#         # - validateGraphBridge() uses a bunch of generated Python code to run in Pyodide s.t. we can just run it here
+
+#         data = request.get_json()
+#         nodes, code_context, node_registry_nodes = data.get("nodes"), data.get("codeContext"), data.get("nodeRegistryNodes")
+#         print("Node registry is: ", node_registry_nodes)
+
+#         # Extract Node Params
+
+
+#         # Validate Graph Bridge
+
+
+#         return jsonify({"success": True, "data": {
+#             "valid": False,
+#             "errors": []
+#         }})
+#         pass
+#     except KeyError as e:
+#         return jsonify({"success": False, "error": f"Missing key, error: {e}"})
+#     except Exception as e:
+#         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+
+
+# # ------------------- STATE DEPENDENT / CHANGING ROUTES ------------------
+
+# @app.route("/continueStreamingSimulation", methods=["POST"])
+# def continueStreamingSimulation():
+#     try:
+#         # Not fully implemented yet
+
+#         data = request.get_json()
+#         duration = data["duration"]
+#     except Exception as e:
+#         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+
+# @app.route("/initialize", methods=["GET"])
+# def initialize():
+#     try:
+#         # Not fully implemented yet
+#         pass
+#     except Exception as e:
+#         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
     
 # Global error handler to ensure all errors return JSON
 @app.errorhandler(Exception)
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 07f05564..2ace93bf 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -3,11 +3,14 @@
  * Executes Python code via Pyodide in a separate thread
  */
 
+// TODO: Need to replace every instance of readPythonAsync with the flask backend call based on the backend preference set
+
 import { PYODIDE_CDN_URL } from '$lib/constants/python';
 import { PROGRESS_MESSAGES, ERROR_MESSAGES } from '$lib/constants/messages';
 import type { REPLRequest, REPLResponse } from '../types';
 
 import type { PyodideInterface } from 'https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs';
+import { backendPreferenceStore } from '$lib/stores';
 
 let pyodide: PyodideInterface | null = null;
 let isInitialized = false;
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index b70bd274..e0beb393 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -759,27 +759,27 @@
 
 				let validation
 
-				if(usingPyodide) {
+				// if(usingPyodide) {
 					validation = await validateGraphSimulation(nodes, codeContext);
-				} else {
-					console.log("[Sending to Flask web server] The node registry is: ", nodeRegistry.getAll())
-					let fetchedData = await fetch(getFlaskBackendUrl()+"/validateGraphSimulation", {
-						method: "POST",
-						body: JSON.stringify({
-							nodes,
-							codeContext,
-							nodeRegistryNodes: nodeRegistry.getAll() // It is necessary to pass in the node registry to the backend since it doesn't have it
-						}),
-						headers: {
-							"Content-Type":"application/json"
-						}
-					}).then(res => res.json())
-					if(!fetchedData.success) {
-						throw Error(fetchedData.error)
-					} else {
-						validation = fetchedData.data satisfies ValidationResult
-					}
-				}
+				// } else {
+				// 	console.log("[Sending to Flask web server] The node registry is: ", nodeRegistry.getAll())
+				// 	let fetchedData = await fetch(getFlaskBackendUrl()+"/validateGraphSimulation", {
+				// 		method: "POST",
+				// 		body: JSON.stringify({
+				// 			nodes,
+				// 			codeContext,
+				// 			nodeRegistryNodes: nodeRegistry.getAll() // It is necessary to pass in the node registry to the backend since it doesn't have it
+				// 		}),
+				// 		headers: {
+				// 			"Content-Type":"application/json"
+				// 		}
+				// 	}).then(res => res.json())
+				// 	if(!fetchedData.success) {
+				// 		throw Error(fetchedData.error)
+				// 	} else {
+				// 		validation = fetchedData.data satisfies ValidationResult
+				// 	}
+				// }
 
 				if (!validation.valid) {
 					// Show validation errors

From cf233c74e5f90ec8faf8c2873422f333f5bacf1f Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 16 Jan 2026 13:05:32 -0500
Subject: [PATCH 12/39] Copied over the worker intialization function

---
 requirements.txt                          |  9 ++-
 src/backend.py                            | 93 +++++++++++++++++++++--
 src/lib/pyodide/backend/pyodide/worker.ts |  2 +
 3 files changed, 97 insertions(+), 7 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index e2b61fe7..cb241c98 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,10 @@
 # Web application dependencies (not needed for core package)
 Flask>=3.1.1
-flask-cors>=6.0.1
\ No newline at end of file
+flask-cors>=6.0.1
+
+numpy
+gc
+pathsim
+pathsim_chem
+io
+contextlib
\ No newline at end of file
diff --git a/src/backend.py b/src/backend.py
index 36cfdeab..67611125 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -4,12 +4,26 @@
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 
+import io
+from contextlib import redirect_stdout, redirect_stderr
+
 '''
 The Flask web server would not be initialized simultaneously with the SvelteKit website since the latter is statically generated,
 rather there would be some type of deployment of this application such that it could receive requests from 
 "https://view.pathsim.org" (which I think is already encapsualted by the "*" in the CORS.resources.options parameter)
 '''
 
+def initialize():
+    # No need for th emicropip installation as the Pyodide backend does it
+    import numpy as np
+    import gc
+    import pathsim, pathsim_chem
+    print(f"PathSim {pathsim.__version__} loaded successfully")
+    
+    _clean_globals = set(globals().keys())
+
+initialize()
+
 app = Flask(__name__, static_folder="../static", static_url_path="")
 
 if os.getenv("FLASK_ENV") == "production":
@@ -31,14 +45,81 @@
         },
         supports_credentials=True
     )
-@app.route("/execute", methods=["POST"])
-def executeCode():
+
+# Execute Python route copied from the previous repository
+@app.route("/execute-python", methods=["POST"])
+def execute_python():
+    """Execute Python code and returns variables/functions."""
+
     try:
-        return jsonify({"success": True, "message": "Hello there"})
-        pass
+        data = request.json
+        code = data.get("code", "")
+
+        if not code.strip():
+            return jsonify({"success": False, "error": "No code provided"}), 400
+
+        # Create a temporary namespace that includes current eval_namespace
+        temp_namespace = {}
+        # temp_namespace.update(globals())
+
+        # Capture stdout and stderr
+        stdout_capture = io.StringIO()
+        stderr_capture = io.StringIO()
+
+        try:
+            with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                exec(code, temp_namespace)
+
+            # Capture any output
+            output = stdout_capture.getvalue()
+            error_output = stderr_capture.getvalue()
+
+            if error_output:
+                return jsonify({"success": False, "error": error_output}), 400
+
+            # Find new variables and functions
+            vars = set(temp_namespace.keys())
+            # new_vars = vars_after - vars_before
+
+            # Filter out built-ins and modules, keep user-defined items
+            user_variables = {}
+            user_functions = []
+
+            for var_name in vars:
+                if not var_name.startswith("__"):
+                    value = temp_namespace[var_name]
+                    if callable(value) and hasattr(value, "__name__"):
+                        user_functions.append(var_name)
+                    else:
+                        # Try to serialize the value for display
+                        try:
+                            if isinstance(value, (int, float, str, bool, list, dict)):
+                                user_variables[var_name] = value
+                            else:
+                                user_variables[var_name] = str(value)
+                        except Exception:
+                            user_variables[var_name] = (
+                                f"<{type(value).__name__} object>"
+                            )
+
+            return jsonify(
+                {
+                    "success": True,
+                    "output": output if output else None,
+                    "variables": user_variables,
+                    "functions": user_functions,
+                    "message": f"Executed successfully. Added {len(user_variables)} variables and {len(user_functions)} functions to namespace.",
+                }
+            )
+
+        except SyntaxError as e:
+            return jsonify({"success": False, "error": f"Syntax Error: {str(e)}"}), 400
+        except Exception as e:
+            return jsonify({"success": False, "error": f"Runtime Error: {str(e)}"}), 400
+
     except Exception as e:
-        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-        
+        return jsonify({"success": False, "error": f"Server error: {str(e)}"}), 500
+    
 # @app.route("/runGraphStreamingSimulation", methods=["POST"])
 # def runGraphStreamingSimulation():
 #     try:
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 2ace93bf..530306a4 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -28,6 +28,8 @@ function send(response: REPLResponse): void {
  * Initialize Pyodide and install packages
  */
 async function initialize(): Promise<void> {
+	console.log(`We are intializing the Pyodide backend but the backend preference is: ${backendPreferenceStore.get()}`)
+	
 	if (isInitialized) {
 		send({ type: 'ready' });
 		return;

From 0ab1841f76dc98c58fb5e859bd4988dc39a0be41 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 16 Jan 2026 13:24:32 -0500
Subject: [PATCH 13/39] Added intializationStatus and the alternative route for
 the pyodide backend to check

---
 src/backend.py                            |  37 +-
 src/lib/constants/messages.ts             |   3 +-
 src/lib/pyodide/backend/pyodide/worker.ts | 397 ++++++++++++----------
 3 files changed, 240 insertions(+), 197 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 67611125..144dfb37 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -13,14 +13,19 @@
 "https://view.pathsim.org" (which I think is already encapsualted by the "*" in the CORS.resources.options parameter)
 '''
 
+isInitialized = False
+
 def initialize():
-    # No need for th emicropip installation as the Pyodide backend does it
+    global isInitialized
+
+    # No need for the micropip installation since only the Pyodide backend needs that installation package
     import numpy as np
     import gc
     import pathsim, pathsim_chem
     print(f"PathSim {pathsim.__version__} loaded successfully")
-    
+
     _clean_globals = set(globals().keys())
+    isInitialized = True
 
 initialize()
 
@@ -177,13 +182,27 @@ def execute_python():
 #     except Exception as e:
 #         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
 
-# @app.route("/initialize", methods=["GET"])
-# def initialize():
-#     try:
-#         # Not fully implemented yet
-#         pass
-#     except Exception as e:
-#         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
+@app.route("/initializationStatus", methods=["GET"])
+def initialize():
+    print("Beginning (or checking) the intialization status of the Flask web server...")
+    try:
+        # Not fully implemented yet
+        if isInitialized:
+            return jsonify({"success": True, "initialized": True})
+        else:
+            count = 0
+
+            # Try three times to run the initialization program and check the status of initialization
+            while count < 3 and not isInitialized:
+                initialize()
+                count += 1
+
+            if isInitialized:
+                return jsonify({"success": True, "initialized": True})
+            else:
+                return jsonify({"success": True, "initialized": False, "error": "Not yet initialized..."})
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
     
 # Global error handler to ensure all errors return JSON
 @app.errorhandler(Exception)
diff --git a/src/lib/constants/messages.ts b/src/lib/constants/messages.ts
index 5f2bd721..1cc7f535 100644
--- a/src/lib/constants/messages.ts
+++ b/src/lib/constants/messages.ts
@@ -7,7 +7,8 @@ export const PROGRESS_MESSAGES = {
 	INSTALLING_DEPS: 'Installing NumPy and SciPy...',
 	INSTALLING_PATHSIM: 'Installing PathSim...',
 	STARTING_WORKER: 'Starting worker...',
-	STARTING_SIMULATION: 'Starting simulation...'
+	STARTING_SIMULATION: 'Starting simulation...',
+	CHECKING_FLASK_INITIALIZATION: 'Checking Flask web server intialization status...'
 } as const;
 
 export const STATUS_MESSAGES = {
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 530306a4..7c06f174 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -5,15 +5,18 @@
 
 // TODO: Need to replace every instance of readPythonAsync with the flask backend call based on the backend preference set
 
-import { PYODIDE_CDN_URL } from '$lib/constants/python';
-import { PROGRESS_MESSAGES, ERROR_MESSAGES } from '$lib/constants/messages';
-import type { REPLRequest, REPLResponse } from '../types';
+import { PYODIDE_CDN_URL } from "$lib/constants/python";
+import { PROGRESS_MESSAGES, ERROR_MESSAGES } from "$lib/constants/messages";
+import type { REPLRequest, REPLResponse } from "../types";
 
-import type { PyodideInterface } from 'https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs';
-import { backendPreferenceStore } from '$lib/stores';
+import type { PyodideInterface } from "https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs";
+import { backendPreferenceStore } from "$lib/stores";
+import type { BackendPreference } from "$lib/types";
+import { getFlaskBackendUrl } from "$lib/utils/flaskRoutes";
 
 let pyodide: PyodideInterface | null = null;
 let isInitialized = false;
+let isFlaskInitialized = false;
 let streamingActive = false;
 const streamingCodeQueue: string[] = [];
 
@@ -21,87 +24,106 @@ const streamingCodeQueue: string[] = [];
  * Send a response to the main thread
  */
 function send(response: REPLResponse): void {
-	postMessage(response);
+  postMessage(response);
 }
 
 /**
  * Initialize Pyodide and install packages
  */
 async function initialize(): Promise<void> {
-	console.log(`We are intializing the Pyodide backend but the backend preference is: ${backendPreferenceStore.get()}`)
-	
-	if (isInitialized) {
-		send({ type: 'ready' });
-		return;
-	}
-
-	send({ type: 'progress', value: PROGRESS_MESSAGES.LOADING_PYODIDE });
-
-	const { loadPyodide } = await import(
-		/* @vite-ignore */
-		PYODIDE_CDN_URL
-	);
-
-	pyodide = await loadPyodide();
-	if (!pyodide) throw new Error(ERROR_MESSAGES.FAILED_TO_LOAD_PYODIDE);
-
-	// Capture stdout/stderr
-	pyodide.setStdout({
-		batched: (msg: string) => send({ type: 'stdout', value: msg })
-	});
-	pyodide.setStderr({
-		batched: (msg: string) => send({ type: 'stderr', value: msg })
-	});
-
-	send({ type: 'progress', value: PROGRESS_MESSAGES.INSTALLING_DEPS });
-	await pyodide.loadPackage(['numpy', 'scipy', 'micropip']);
-
-	send({ type: 'progress', value: PROGRESS_MESSAGES.INSTALLING_PATHSIM });
-	await pyodide.runPythonAsync(`
+  // console.log(`We are intializing the Pyodide backend but the backend preference is: ${backendPreferenceStore.get()}`)
+  let preference: BackendPreference = backendPreferenceStore.get();
+
+  if (preference == "pyodide") {
+    if (isInitialized) {
+      send({ type: "ready" });
+      return;
+    }
+
+    send({ type: "progress", value: PROGRESS_MESSAGES.LOADING_PYODIDE });
+
+    const { loadPyodide } = await import(
+      /* @vite-ignore */
+      PYODIDE_CDN_URL
+    );
+
+    pyodide = await loadPyodide();
+    if (!pyodide) throw new Error(ERROR_MESSAGES.FAILED_TO_LOAD_PYODIDE);
+
+    // Capture stdout/stderr
+    pyodide.setStdout({
+      batched: (msg: string) => send({ type: "stdout", value: msg }),
+    });
+    pyodide.setStderr({
+      batched: (msg: string) => send({ type: "stderr", value: msg }),
+    });
+
+    send({ type: "progress", value: PROGRESS_MESSAGES.INSTALLING_DEPS });
+    await pyodide.loadPackage(["numpy", "scipy", "micropip"]);
+
+    send({ type: "progress", value: PROGRESS_MESSAGES.INSTALLING_PATHSIM });
+    await pyodide.runPythonAsync(`
 import micropip
 await micropip.install('pathsim')
 	`);
 
-	// Verify and print version
-	await pyodide.runPythonAsync(`
+    // Verify and print version
+    await pyodide.runPythonAsync(`
 import pathsim
 print(f"PathSim {pathsim.__version__} loaded successfully")
 	`);
 
-	// Import numpy as np and gc globally
-	await pyodide.runPythonAsync(`import numpy as np`);
-	await pyodide.runPythonAsync(`import gc`);
+    // Import numpy as np and gc globally
+    await pyodide.runPythonAsync(`import numpy as np`);
+    await pyodide.runPythonAsync(`import gc`);
+
+    // Capture clean state for later cleanup
+    await pyodide.runPythonAsync(`_clean_globals = set(globals().keys())`);
 
-	// Capture clean state for later cleanup
-	await pyodide.runPythonAsync(`_clean_globals = set(globals().keys())`);
+    isInitialized = true;
+    send({ type: "ready" });
+  } else {
+	/*	We have configured for a Flask backend preference so we send the request to intializes, 
+		the flask backend (if online) has already run the initialization function
+		*/
 
-	isInitialized = true;
-	send({ type: 'ready' });
+	if(isFlaskInitialized) {
+      send({ type: "ready" });
+      return;
+	}
+
+	send({ type: "progress", value: PROGRESS_MESSAGES.CHECKING_FLASK_INITIALIZATION})
+	let data = await fetch(getFlaskBackendUrl()+"/initialized").then(res => res.json())
+	if(data.success && data.isInitialized) {
+		isFlaskInitialized = true
+		send({type: "ready"})
+	}
+  }
 }
 
 /**
  * Execute Python code (no return value)
  */
 async function execCode(id: string, code: string): Promise<void> {
-	if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
-
-	try {
-		await pyodide.runPythonAsync(code);
-		send({ type: 'ok', id });
-	} catch (error) {
-		const errorMsg = error instanceof Error ? error.message : String(error);
-		// Try to get traceback
-		let traceback: string | undefined;
-		try {
-			traceback = (await pyodide.runPythonAsync(`
+  if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+
+  try {
+    await pyodide.runPythonAsync(code);
+    send({ type: "ok", id });
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    // Try to get traceback
+    let traceback: string | undefined;
+    try {
+      traceback = (await pyodide.runPythonAsync(`
 import traceback
 traceback.format_exc()
 			`)) as string;
-		} catch {
-			// Ignore traceback extraction errors
-		}
-		send({ type: 'error', id, error: errorMsg, traceback });
-	}
+    } catch {
+      // Ignore traceback extraction errors
+    }
+    send({ type: "error", id, error: errorMsg, traceback });
+  }
 }
 
 /**
@@ -109,28 +131,28 @@ traceback.format_exc()
  * Note: _to_json helper is injected via REPL_SETUP_CODE
  */
 async function evalExpr(id: string, expr: string): Promise<void> {
-	if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+  if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
 
-	try {
-		const result = await pyodide.runPythonAsync(`
+  try {
+    const result = await pyodide.runPythonAsync(`
 _eval_result = ${expr}
 json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
 		`);
 
-		send({ type: 'value', id, value: result as string });
-	} catch (error) {
-		const errorMsg = error instanceof Error ? error.message : String(error);
-		let traceback: string | undefined;
-		try {
-			traceback = (await pyodide.runPythonAsync(`
+    send({ type: "value", id, value: result as string });
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    let traceback: string | undefined;
+    try {
+      traceback = (await pyodide.runPythonAsync(`
 import traceback
 traceback.format_exc()
 			`)) as string;
-		} catch {
-			// Ignore
-		}
-		send({ type: 'error', id, error: errorMsg, traceback });
-	}
+    } catch {
+      // Ignore
+    }
+    send({ type: "error", id, error: errorMsg, traceback });
+  }
 }
 
 /**
@@ -138,132 +160,133 @@ traceback.format_exc()
  * Runs autonomously until done or stopped
  */
 async function runStreamingLoop(id: string, expr: string): Promise<void> {
-	if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
-
-	streamingActive = true;
-	// Clear any stale code from previous runs
-	streamingCodeQueue.length = 0;
-
-	try {
-		while (streamingActive) {
-			// Execute any queued code first (for runtime parameter changes, events, etc.)
-			// Errors in queued code are reported but don't stop the simulation
-			while (streamingCodeQueue.length > 0) {
-				const code = streamingCodeQueue.shift()!;
-				try {
-					await pyodide.runPythonAsync(code);
-				} catch (error) {
-					const errorMsg = error instanceof Error ? error.message : String(error);
-					send({ type: 'stderr', value: `Stream exec error: ${errorMsg}` });
-				}
-			}
-
-			// Step the generator
-			const result = await pyodide.runPythonAsync(`
+  if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+
+  streamingActive = true;
+  // Clear any stale code from previous runs
+  streamingCodeQueue.length = 0;
+
+  try {
+    while (streamingActive) {
+      // Execute any queued code first (for runtime parameter changes, events, etc.)
+      // Errors in queued code are reported but don't stop the simulation
+      while (streamingCodeQueue.length > 0) {
+        const code = streamingCodeQueue.shift()!;
+        try {
+          await pyodide.runPythonAsync(code);
+        } catch (error) {
+          const errorMsg =
+            error instanceof Error ? error.message : String(error);
+          send({ type: "stderr", value: `Stream exec error: ${errorMsg}` });
+        }
+      }
+
+      // Step the generator
+      const result = await pyodide.runPythonAsync(`
 _eval_result = ${expr}
 json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
 			`);
 
-			// Parse result
-			const parsed = JSON.parse(result as string);
-
-			// Check if stopped during Python execution - still send final data
-			if (!streamingActive) {
-				if (!parsed.done && parsed.result) {
-					send({ type: 'stream-data', id, value: result as string });
-				}
-				break;
-			}
-
-			// Check if simulation completed
-			if (parsed.done) {
-				break;
-			}
-
-			// Send result and continue
-			send({ type: 'stream-data', id, value: result as string });
-		}
-	} catch (error) {
-		const errorMsg = error instanceof Error ? error.message : String(error);
-		let traceback: string | undefined;
-		try {
-			traceback = (await pyodide.runPythonAsync(`
+      // Parse result
+      const parsed = JSON.parse(result as string);
+
+      // Check if stopped during Python execution - still send final data
+      if (!streamingActive) {
+        if (!parsed.done && parsed.result) {
+          send({ type: "stream-data", id, value: result as string });
+        }
+        break;
+      }
+
+      // Check if simulation completed
+      if (parsed.done) {
+        break;
+      }
+
+      // Send result and continue
+      send({ type: "stream-data", id, value: result as string });
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    let traceback: string | undefined;
+    try {
+      traceback = (await pyodide.runPythonAsync(`
 import traceback
 traceback.format_exc()
 			`)) as string;
-		} catch {
-			// Ignore
-		}
-		send({ type: 'error', id, error: errorMsg, traceback });
-	} finally {
-		streamingActive = false;
-		// Always send done when loop ends (whether completed, stopped, or error)
-		send({ type: 'stream-done', id });
-	}
+    } catch {
+      // Ignore
+    }
+    send({ type: "error", id, error: errorMsg, traceback });
+  } finally {
+    streamingActive = false;
+    // Always send done when loop ends (whether completed, stopped, or error)
+    send({ type: "stream-done", id });
+  }
 }
 
 /**
- * Stop streaming loop
+ * Stop streaming loop - Don't need to affect this since streaming status can still be handled by the client
  */
 function stopStreaming(): void {
-	streamingActive = false;
+  streamingActive = false;
 }
 
 // Handle messages from main thread
 self.onmessage = async (event: MessageEvent<REPLRequest>) => {
-	const { type } = event.data;
-	// Extract fields based on request type
-	const id = 'id' in event.data ? event.data.id : undefined;
-	const code = 'code' in event.data ? event.data.code : undefined;
-	const expr = 'expr' in event.data ? event.data.expr : undefined;
-
-	try {
-		switch (type) {
-			case 'init':
-				await initialize();
-				break;
-
-			case 'exec':
-				if (!id || typeof code !== 'string') {
-					throw new Error('Invalid exec request: missing id or code');
-				}
-				await execCode(id, code);
-				break;
-
-			case 'eval':
-				if (!id || typeof expr !== 'string') {
-					throw new Error('Invalid eval request: missing id or expr');
-				}
-				await evalExpr(id, expr);
-				break;
-
-			case 'stream-start':
-				if (!id || typeof expr !== 'string') {
-					throw new Error('Invalid stream-start request: missing id or expr');
-				}
-				// Don't await - let it run autonomously
-				runStreamingLoop(id, expr);
-				break;
-
-			case 'stream-stop':
-				stopStreaming();
-				break;
-
-			case 'stream-exec':
-				if (typeof code === 'string' && streamingActive) {
-					// Queue code to be executed between generator steps
-					streamingCodeQueue.push(code);
-				}
-				break;
-
-			default:
-				throw new Error(`Unknown message type: ${type}`);
-		}
-	} catch (error) {
-		send({
-			type: 'error',
-			id,
-			error: error instanceof Error ? error.message : String(error)
-		});
-	}
+  const { type } = event.data;
+  // Extract fields based on request type
+  const id = "id" in event.data ? event.data.id : undefined;
+  const code = "code" in event.data ? event.data.code : undefined;
+  const expr = "expr" in event.data ? event.data.expr : undefined;
+
+  try {
+    switch (type) {
+      case "init":
+        await initialize();
+        break;
+
+      case "exec":
+        if (!id || typeof code !== "string") {
+          throw new Error("Invalid exec request: missing id or code");
+        }
+        await execCode(id, code);
+        break;
+
+      case "eval":
+        if (!id || typeof expr !== "string") {
+          throw new Error("Invalid eval request: missing id or expr");
+        }
+        await evalExpr(id, expr);
+        break;
+
+      case "stream-start":
+        if (!id || typeof expr !== "string") {
+          throw new Error("Invalid stream-start request: missing id or expr");
+        }
+        // Don't await - let it run autonomously
+        runStreamingLoop(id, expr);
+        break;
+
+      case "stream-stop":
+        stopStreaming();
+        break;
+
+      case "stream-exec":
+        if (typeof code === "string" && streamingActive) {
+          // Queue code to be executed between generator steps
+          streamingCodeQueue.push(code);
+        }
+        break;
+
+      default:
+        throw new Error(`Unknown message type: ${type}`);
+    }
+  } catch (error) {
+    send({
+      type: "error",
+      id,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
 };

From c8a2f2607ea985f0414ecaf53a310830c9b918f1 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 16 Jan 2026 14:40:59 -0500
Subject: [PATCH 14/39] Small changes finished, don't know why I am having so
 many complications with localStorage

---
 src/backend.py                            |  9 ++++++---
 src/lib/pyodide/backend/pyodide/worker.ts | 18 +++++++++++-------
 src/lib/pyodide/pathsimRunner.ts          |  1 -
 src/lib/stores/theme.ts                   |  1 +
 src/routes/+page.svelte                   |  6 ++++--
 5 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 144dfb37..26f5d397 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -27,7 +27,7 @@ def initialize():
     _clean_globals = set(globals().keys())
     isInitialized = True
 
-initialize()
+# initialize()
 
 app = Flask(__name__, static_folder="../static", static_url_path="")
 
@@ -183,8 +183,9 @@ def execute_python():
 #         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
 
 @app.route("/initializationStatus", methods=["GET"])
-def initialize():
-    print("Beginning (or checking) the intialization status of the Flask web server...")
+def initializationStatus():
+    print("Checking the intialization status of the Flask web server...")
+
     try:
         # Not fully implemented yet
         if isInitialized:
@@ -194,7 +195,9 @@ def initialize():
 
             # Try three times to run the initialization program and check the status of initialization
             while count < 3 and not isInitialized:
+                print(f"Attempting to initialize...")
                 initialize()
+                print(f"This is attempt {count}")
                 count += 1
 
             if isInitialized:
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 7c06f174..41e7ca10 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -28,10 +28,12 @@ function send(response: REPLResponse): void {
 }
 
 /**
- * Initialize Pyodide and install packages
+ * Initialize Pyodide and install packages (Needs FLASK Rework)
  */
 async function initialize(): Promise<void> {
-  // console.log(`We are intializing the Pyodide backend but the backend preference is: ${backendPreferenceStore.get()}`)
+
+  console.log(`We are intializing the Pyodide backend but the backend preference is: ${backendPreferenceStore.get()}`)
+
   let preference: BackendPreference = backendPreferenceStore.get();
 
   if (preference == "pyodide") {
@@ -87,13 +89,15 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
 		the flask backend (if online) has already run the initialization function
 		*/
 
+	console.log("Checking the status of the Flask web server....")
+
 	if(isFlaskInitialized) {
       send({ type: "ready" });
       return;
 	}
 
 	send({ type: "progress", value: PROGRESS_MESSAGES.CHECKING_FLASK_INITIALIZATION})
-	let data = await fetch(getFlaskBackendUrl()+"/initialized").then(res => res.json())
+	let data = await fetch(getFlaskBackendUrl()+"/initializationStatus").then(res => res.json())
 	if(data.success && data.isInitialized) {
 		isFlaskInitialized = true
 		send({type: "ready"})
@@ -102,7 +106,7 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
 }
 
 /**
- * Execute Python code (no return value)
+ * Execute Python code (no return value) (Needs FLASK Rework)
  */
 async function execCode(id: string, code: string): Promise<void> {
   if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
@@ -128,7 +132,7 @@ traceback.format_exc()
 
 /**
  * Evaluate Python expression and return JSON result
- * Note: _to_json helper is injected via REPL_SETUP_CODE
+ * Note: _to_json helper is injected via REPL_SETUP_CODE (Needs FLASK Rework)
  */
 async function evalExpr(id: string, expr: string): Promise<void> {
   if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
@@ -157,7 +161,7 @@ traceback.format_exc()
 
 /**
  * Run streaming loop - steps generator continuously and posts results
- * Runs autonomously until done or stopped
+ * Runs autonomously until done or stopped (Needs FLASK Rework)
  */
 async function runStreamingLoop(id: string, expr: string): Promise<void> {
   if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
@@ -226,7 +230,7 @@ traceback.format_exc()
 }
 
 /**
- * Stop streaming loop - Don't need to affect this since streaming status can still be handled by the client
+ * Stop streaming loop
  */
 function stopStreaming(): void {
   streamingActive = false;
diff --git a/src/lib/pyodide/pathsimRunner.ts b/src/lib/pyodide/pathsimRunner.ts
index 0cf446c5..2e12cb7f 100644
--- a/src/lib/pyodide/pathsimRunner.ts
+++ b/src/lib/pyodide/pathsimRunner.ts
@@ -1035,7 +1035,6 @@ function extractNodeParams(nodes: NodeInstance[]): Record<string, Record<string,
 	const result: Record<string, Record<string, string>> = {};
 
 	for (const node of nodes) {
-		console.log("The node registry is: ", nodeRegistry)
 		const typeDef = nodeRegistry.get(node.type);
 		if (!typeDef) continue;
 
diff --git a/src/lib/stores/theme.ts b/src/lib/stores/theme.ts
index 095a2ca8..ecd142e6 100644
--- a/src/lib/stores/theme.ts
+++ b/src/lib/stores/theme.ts
@@ -12,6 +12,7 @@ export type Theme = 'light' | 'dark';
 function getInitialTheme(): Theme {
 	if (!browser) return 'dark';
 
+	console.log("Running on the browser: ", browser)
 	const stored = localStorage.getItem('pathview-theme');
 	if (stored === 'light' || stored === 'dark') {
 		return stored;
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index e0beb393..070f73b2 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -61,8 +61,9 @@
 	// Console Specific Settings and Actions
 	import { newGraph, openFile, saveFile, saveAsFile, setupAutoSave, clearAutoSave, debouncedAutoSave, loadGraphFromUrl, currentFileName } from '$lib/schema/fileOps';
 	import { triggerFitView, triggerZoomIn, triggerZoomOut, triggerPan, getViewportCenter, screenToFlow, triggerClearSelection, triggerNudge, hasAnySelection, setFitViewPadding } from '$lib/stores/viewActions';
-  import { getFlaskBackendUrl } from '$lib/utils/flaskRoutes';
-  import type { ValidationResult } from '$lib/types';
+  	
+	import { getFlaskBackendUrl } from '$lib/utils/flaskRoutes';
+  	import type { ValidationResult } from '$lib/types';
 
 	// --------------------------- ROOT PAGE IMPORTS | END ---------------------------
 
@@ -726,6 +727,7 @@
 		// Auto-initialize if not ready
 		if (!pyodideReady && usingPyodide) {
 			try {
+				console.log("Initializing Pyodide")
 				await initPyodide();
 			} catch (error) {
 				console.error('Failed to initialize Pyodide:', error);

From e886570ceebbe60ad5e3fe5819c704c398254ab8 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 16 Jan 2026 16:52:52 -0500
Subject: [PATCH 15/39] Need to work on passing the backend preference top down
 from handlers -> Pyodide backend -> workers in order to avoid accessing
 localStorage from the level of the workers in the Pyodide backend

---
 src/backend.py                             | 145 +++++++++----------
 src/lib/pyodide/backend/pyodide/backend.ts |   7 +
 src/lib/pyodide/backend/pyodide/worker.ts  | 161 ++++++++++++++-------
 src/lib/stores/backendPreference.ts        |   8 +-
 src/lib/stores/theme.ts                    |  11 +-
 src/routes/+page.svelte                    |   4 +-
 6 files changed, 203 insertions(+), 133 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 26f5d397..7f1f4517 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -1,5 +1,6 @@
 import os
 import json
+import traceback
 import requests as req
 from flask import Flask, request, jsonify
 from flask_cors import CORS
@@ -7,27 +8,23 @@
 import io
 from contextlib import redirect_stdout, redirect_stderr
 
+# Initialization Code
+
+import numpy as np
+import gc
+import pathsim, pathsim_chem
+
+print(f"PathSim {pathsim.__version__} loaded successfully")
+    
+_clean_globals = set(globals().keys())
+namespace = {}
+
 '''
 The Flask web server would not be initialized simultaneously with the SvelteKit website since the latter is statically generated,
 rather there would be some type of deployment of this application such that it could receive requests from 
 "https://view.pathsim.org" (which I think is already encapsualted by the "*" in the CORS.resources.options parameter)
 '''
 
-isInitialized = False
-
-def initialize():
-    global isInitialized
-
-    # No need for the micropip installation since only the Pyodide backend needs that installation package
-    import numpy as np
-    import gc
-    import pathsim, pathsim_chem
-    print(f"PathSim {pathsim.__version__} loaded successfully")
-
-    _clean_globals = set(globals().keys())
-    isInitialized = True
-
-# initialize()
 
 app = Flask(__name__, static_folder="../static", static_url_path="")
 
@@ -52,9 +49,9 @@ def initialize():
     )
 
 # Execute Python route copied from the previous repository
-@app.route("/execute-python", methods=["POST"])
-def execute_python():
-    """Execute Python code and returns variables/functions."""
+@app.route("/execute-code", methods=["POST"])
+def execute_code():
+    """Execute Python code and returns nothing."""
 
     try:
         data = request.json
@@ -64,7 +61,7 @@ def execute_python():
             return jsonify({"success": False, "error": "No code provided"}), 400
 
         # Create a temporary namespace that includes current eval_namespace
-        temp_namespace = {}
+        # temp_namespace = {}
         # temp_namespace.update(globals())
 
         # Capture stdout and stderr
@@ -73,7 +70,7 @@ def execute_python():
 
         try:
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                exec(code, temp_namespace)
+                exec(code, namespace)
 
             # Capture any output
             output = stdout_capture.getvalue()
@@ -81,50 +78,71 @@ def execute_python():
 
             if error_output:
                 return jsonify({"success": False, "error": error_output}), 400
+            
+            return jsonify(
+                {
+                    "success": True
+                }
+            )
+
+        except SyntaxError as e:
+            return jsonify({"success": False, "error": f"Syntax Error: {str(e)}"}), 400
+        except Exception as e:
+            return jsonify({"success": False, "error": f"Runtime Error: {str(e)}"}), 400
+
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server error: {str(e)}"}), 500
+
+@app.route("/evaluate-expression", methods=["POST"])
+def evaluate_expression():
+    "Evaluates Python expression and returns result"
+    try:
+        data = request.json
+        expr = data.get("expr")
+        
+        if not expr.strip():
+            return jsonify({"success": False, "error": "No Python expression provided"}), 400
+        
+        # temp_namespace = {}
 
-            # Find new variables and functions
-            vars = set(temp_namespace.keys())
-            # new_vars = vars_after - vars_before
-
-            # Filter out built-ins and modules, keep user-defined items
-            user_variables = {}
-            user_functions = []
-
-            for var_name in vars:
-                if not var_name.startswith("__"):
-                    value = temp_namespace[var_name]
-                    if callable(value) and hasattr(value, "__name__"):
-                        user_functions.append(var_name)
-                    else:
-                        # Try to serialize the value for display
-                        try:
-                            if isinstance(value, (int, float, str, bool, list, dict)):
-                                user_variables[var_name] = value
-                            else:
-                                user_variables[var_name] = str(value)
-                        except Exception:
-                            user_variables[var_name] = (
-                                f"<{type(value).__name__} object>"
-                            )
+        stdout_capture = io.StringIO()
+        stderr_capture = io.StringIO()
+
+        try:
+            result = ""
+            with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                result = eval(expr, namespace)
+
+            # Capture any output
+            output = stdout_capture.getvalue()
+            error_output = stderr_capture.getvalue()
 
+            if error_output:
+                return jsonify({"success": False, "error": error_output}), 400
+            
             return jsonify(
                 {
                     "success": True,
-                    "output": output if output else None,
-                    "variables": user_variables,
-                    "functions": user_functions,
-                    "message": f"Executed successfully. Added {len(user_variables)} variables and {len(user_functions)} functions to namespace.",
+                    "result": result
                 }
             )
 
         except SyntaxError as e:
             return jsonify({"success": False, "error": f"Syntax Error: {str(e)}"}), 400
         except Exception as e:
-            return jsonify({"success": False, "error": f"Runtime Error: {str(e)}"}), 400
-
+            return jsonify({"success": False, "error": f"Runtime Error: {str(e)}"}), 400 
     except Exception as e:
         return jsonify({"success": False, "error": f"Server error: {str(e)}"}), 500
-    
+
+
+@app.route("/traceback", methods=["GET"])
+def check_traceback():
+    try:
+        traceback_text = traceback.format_exc()
+        return jsonify({"success": True, "traceback": traceback_text})
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server-side error: {e}"})
+
 # @app.route("/runGraphStreamingSimulation", methods=["POST"])
 # def runGraphStreamingSimulation():
 #     try:
@@ -182,31 +200,6 @@ def execute_python():
 #     except Exception as e:
 #         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
 
-@app.route("/initializationStatus", methods=["GET"])
-def initializationStatus():
-    print("Checking the intialization status of the Flask web server...")
-
-    try:
-        # Not fully implemented yet
-        if isInitialized:
-            return jsonify({"success": True, "initialized": True})
-        else:
-            count = 0
-
-            # Try three times to run the initialization program and check the status of initialization
-            while count < 3 and not isInitialized:
-                print(f"Attempting to initialize...")
-                initialize()
-                print(f"This is attempt {count}")
-                count += 1
-
-            if isInitialized:
-                return jsonify({"success": True, "initialized": True})
-            else:
-                return jsonify({"success": True, "initialized": False, "error": "Not yet initialized..."})
-    except Exception as e:
-        return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-    
 # Global error handler to ensure all errors return JSON
 @app.errorhandler(Exception)
 def handle_exception(e):
diff --git a/src/lib/pyodide/backend/pyodide/backend.ts b/src/lib/pyodide/backend/pyodide/backend.ts
index 93d4d1b0..264b1408 100644
--- a/src/lib/pyodide/backend/pyodide/backend.ts
+++ b/src/lib/pyodide/backend/pyodide/backend.ts
@@ -8,6 +8,7 @@ import type { Backend, BackendState, REPLRequest, REPLResponse, REPLErrorRespons
 import { backendState } from '../state';
 import { TIMEOUTS } from '$lib/constants/python';
 import { PROGRESS_MESSAGES, STATUS_MESSAGES } from '$lib/constants/messages';
+import type { BackendPreference } from '$lib/types';
 
 interface PendingRequest {
 	resolve: (value: string | undefined) => void;
@@ -33,6 +34,7 @@ export class PyodideBackend implements Backend {
 	private messageId = 0;
 	private pendingRequests = new Map<string, PendingRequest>();
 	private isInitializing = false;
+	private backendPreference : BackendPreference = "pyodide";
 
 	private streamState: StreamState = {
 		id: null,
@@ -168,6 +170,10 @@ export class PyodideBackend implements Backend {
 	getError(): string | null {
 		return this.getState().error;
 	}
+	
+	setBackendPreference(preference : BackendPreference): void {
+		this.backendPreference = preference
+	}
 
 	// -------------------------------------------------------------------------
 	// Execution
@@ -318,6 +324,7 @@ export class PyodideBackend implements Backend {
 
 	private sendRequest(request: REPLRequest): void {
 		if (!this.worker) {
+			console.log(`Within sendRequest() I have an uninitialized worker!`) // Debugging console
 			throw new Error('Worker not initialized');
 		}
 		this.worker.postMessage(request);
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 41e7ca10..043e202d 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -7,7 +7,7 @@
 
 import { PYODIDE_CDN_URL } from "$lib/constants/python";
 import { PROGRESS_MESSAGES, ERROR_MESSAGES } from "$lib/constants/messages";
-import type { REPLRequest, REPLResponse } from "../types";
+import type { Backend, REPLRequest, REPLResponse } from "../types";
 
 import type { PyodideInterface } from "https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs";
 import { backendPreferenceStore } from "$lib/stores";
@@ -16,7 +16,8 @@ import { getFlaskBackendUrl } from "$lib/utils/flaskRoutes";
 
 let pyodide: PyodideInterface | null = null;
 let isInitialized = false;
-let isFlaskInitialized = false;
+let backendPreference : null | BackendPreference = null
+let isFlaskInitialized = true;
 let streamingActive = false;
 const streamingCodeQueue: string[] = [];
 
@@ -31,12 +32,7 @@ function send(response: REPLResponse): void {
  * Initialize Pyodide and install packages (Needs FLASK Rework)
  */
 async function initialize(): Promise<void> {
-
-  console.log(`We are intializing the Pyodide backend but the backend preference is: ${backendPreferenceStore.get()}`)
-
-  let preference: BackendPreference = backendPreferenceStore.get();
-
-  if (preference == "pyodide") {
+  if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (isInitialized) {
       send({ type: "ready" });
       return;
@@ -85,23 +81,15 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
     isInitialized = true;
     send({ type: "ready" });
   } else {
-	/*	We have configured for a Flask backend preference so we send the request to intializes, 
-		the flask backend (if online) has already run the initialization function
-		*/
+    /*	By default the isFlaskInitialized variable is true as we have the backend constantly running on a hosted server
+     */
 
-	console.log("Checking the status of the Flask web server....")
+    console.log(
+      "We are ready, this is a flask web server so we don't concern with initialization"
+    );
+    send({ type: "ready" });
 
-	if(isFlaskInitialized) {
-      send({ type: "ready" });
-      return;
-	}
-
-	send({ type: "progress", value: PROGRESS_MESSAGES.CHECKING_FLASK_INITIALIZATION})
-	let data = await fetch(getFlaskBackendUrl()+"/initializationStatus").then(res => res.json())
-	if(data.success && data.isInitialized) {
-		isFlaskInitialized = true
-		send({type: "ready"})
-	}
+    return;
   }
 }
 
@@ -109,56 +97,127 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
  * Execute Python code (no return value) (Needs FLASK Rework)
  */
 async function execCode(id: string, code: string): Promise<void> {
-  if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
-
-  try {
-    await pyodide.runPythonAsync(code);
-    send({ type: "ok", id });
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    // Try to get traceback
-    let traceback: string | undefined;
+  if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
+    if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
     try {
-      traceback = (await pyodide.runPythonAsync(`
+      await pyodide.runPythonAsync(code);
+      send({ type: "ok", id });
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      // Try to get traceback
+      let traceback: string | undefined;
+      try {
+        traceback = (await pyodide.runPythonAsync(`
 import traceback
 traceback.format_exc()
 			`)) as string;
-    } catch {
-      // Ignore traceback extraction errors
+      } catch {
+        // Ignore traceback extraction errors
+      }
+      send({ type: "error", id, error: errorMsg, traceback });
     }
-    send({ type: "error", id, error: errorMsg, traceback });
+  } else {
+    return execCodeWithFlask(id, code)
   }
 }
 
+async function execCodeWithFlask(id: string, code: string): Promise <void> {
+    try {
+      let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({code: code})
+      }).then(
+        (res) => res.json()
+      );
+      if (data.success) {
+        send({ type: "ok", id });
+      } else {
+        throw Error(data.error);
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      let traceback: string | undefined;
+      try {
+        traceback = (
+          await fetch(getFlaskBackendUrl() + "/traceback")
+            .then((res) => res.json())
+            .then((res) => res.json)
+        ).traceback as string;
+      } catch (error) {
+        // Ignore as in the Pyodide framework
+      }
+      send({ type: "error", id, error: errorMsg, traceback });
+    }
+}
+
 /**
  * Evaluate Python expression and return JSON result
  * Note: _to_json helper is injected via REPL_SETUP_CODE (Needs FLASK Rework)
  */
-async function evalExpr(id: string, expr: string): Promise<void> {
-  if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+async function evalExpr(id: string, expr: string, backendPreference = null): Promise<void> {
+  if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
+    if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
 
-  try {
-    const result = await pyodide.runPythonAsync(`
+    try {
+      const result = await pyodide.runPythonAsync(`
 _eval_result = ${expr}
 json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
 		`);
 
-    send({ type: "value", id, value: result as string });
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    let traceback: string | undefined;
-    try {
-      traceback = (await pyodide.runPythonAsync(`
+      send({ type: "value", id, value: result as string });
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      let traceback: string | undefined;
+      try {
+        traceback = (await pyodide.runPythonAsync(`
 import traceback
 traceback.format_exc()
 			`)) as string;
-    } catch {
-      // Ignore
+      } catch {
+        // Ignore
+      }
+      send({ type: "error", id, error: errorMsg, traceback });
     }
-    send({ type: "error", id, error: errorMsg, traceback });
+  } else {
+    return evalExprWithFlask(id, expr)
   }
 }
 
+async function evalExprWithFlask(id: string, expr: string) : Promise<void> {
+    try {
+      let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({expr: expr})
+      }).then(
+        (res) => res.json()
+      );
+      
+      if (data.success) {
+        send({ type: "value", id, value: data.result as string });
+      } else {
+        throw Error(data.error);
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      let traceback: string | undefined;
+      try {
+        traceback = (
+          await fetch(getFlaskBackendUrl() + "/traceback")
+            .then((res) => res.json())
+            .then((res) => res.json)
+        ).traceback as string;
+      } catch (error) {
+        // Ignore as in the Pyodide framework
+      }
+      send({ type: "error", id, error: errorMsg, traceback });
+    }
+}
 /**
  * Run streaming loop - steps generator continuously and posts results
  * Runs autonomously until done or stopped (Needs FLASK Rework)
@@ -236,6 +295,10 @@ function stopStreaming(): void {
   streamingActive = false;
 }
 
+function setBackendPreference(preference : BackendPreference): void {
+  backendPreference = preference
+}
+
 // Handle messages from main thread
 self.onmessage = async (event: MessageEvent<REPLRequest>) => {
   const { type } = event.data;
diff --git a/src/lib/stores/backendPreference.ts b/src/lib/stores/backendPreference.ts
index f7889d59..5f6f66cc 100644
--- a/src/lib/stores/backendPreference.ts
+++ b/src/lib/stores/backendPreference.ts
@@ -11,7 +11,7 @@ export type BackendPreference = 'pyodide' | 'flask';
 
 // Get initial backend preference from localStorage or system preference
 function getIntialBackendPreference(): BackendPreference {
-	if (!browser) return 'pyodide';
+	if (!browser || typeof window == "undefined") return 'flask';
 
 	const stored = localStorage.getItem('pathview-backend-preference');
 	if (stored === 'pyodide' || stored === 'flask') {
@@ -26,7 +26,7 @@ const backendPreference = writable<BackendPreference>(getIntialBackendPreference
 
 // Apply backend preference to document and persist
 backendPreference.subscribe((value) => {
-	if (!browser) return;
+	if (!browser || typeof window == "undefined") return;
 
 	// Persist to localStorage
 	localStorage.setItem('pathview-backend-preference', value);
@@ -41,6 +41,10 @@ export const backendPreferenceStore = {
 	 */
 	toggle(): void {
 		backendPreference.update((current) => (current === 'pyodide' ? 'flask' : 'pyodide'));
+		if(typeof window !== "undefined") {
+			// To avoid complications with the initialization state of the Pyodide Backend class I will just reload the page
+			window.location.reload()
+		}
 	},
 
 	/**
diff --git a/src/lib/stores/theme.ts b/src/lib/stores/theme.ts
index ecd142e6..f23925f0 100644
--- a/src/lib/stores/theme.ts
+++ b/src/lib/stores/theme.ts
@@ -10,9 +10,12 @@ export type Theme = 'light' | 'dark';
 
 // Get initial theme from localStorage or system preference
 function getInitialTheme(): Theme {
-	if (!browser) return 'dark';
+	if (!browser || typeof window == "undefined") return 'dark';
 
-	console.log("Running on the browser: ", browser)
+	console.log(`Are we running on the browser?`, browser)
+	console.log("Local Storage type is ", typeof localStorage)
+	console.log("Window type is ", typeof window)
+	console.log(`Local Storage object:`, localStorage)
 	const stored = localStorage.getItem('pathview-theme');
 	if (stored === 'light' || stored === 'dark') {
 		return stored;
@@ -31,7 +34,7 @@ const theme = writable<Theme>(getInitialTheme());
 
 // Apply theme to document and persist
 theme.subscribe((value) => {
-	if (!browser) return;
+	if (!browser || typeof window == "undefined") return;
 
 	// Set data-theme attribute on document
 	document.documentElement.setAttribute('data-theme', value);
@@ -66,4 +69,4 @@ export const themeStore = {
 		theme.subscribe((value) => (current = value))();
 		return current;
 	}
-};
+};
\ No newline at end of file
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 070f73b2..141149e7 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -391,6 +391,7 @@
 		});
 
 		const unsubTheme = themeStore.subscribe((theme) => {
+			console.log("Unsubscribing from the theme store")
 			currentTheme = theme;
 		});
 
@@ -709,8 +710,7 @@
 	// Run simulation (auto-initializes if needed) - Interacts with "backend"
 	async function handleRun() {
 		// Logging the current backend preference
-		console.log(`The current backend preference is ${currentBackendPreference}`)
-		console.log("The current node registry that the front-end recognizes is: ", nodeRegistry)
+		console.log(`(+page.svelte) The current backend preference is ${currentBackendPreference}`)
 
 		let usingPyodide = currentBackendPreference == "pyodide"
 

From d97cc4a0f438483ebebad73c640bd2ce801bd50a Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 16 Jan 2026 17:16:22 -0500
Subject: [PATCH 16/39] May need to rever the backendPreferenceStore system

---
 src/backend.py                            |  1 -
 src/lib/pyodide/backend/pyodide/worker.ts | 16 +++++++++++++++-
 src/lib/pyodide/pathsimRunner.ts          |  6 ++++--
 src/routes/+page.svelte                   |  2 +-
 4 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 7f1f4517..b9bb2efd 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -103,7 +103,6 @@ def evaluate_expression():
         if not expr.strip():
             return jsonify({"success": False, "error": "No Python expression provided"}), 400
         
-        # temp_namespace = {}
 
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 043e202d..22d99c6d 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -9,6 +9,7 @@ import { PYODIDE_CDN_URL } from "$lib/constants/python";
 import { PROGRESS_MESSAGES, ERROR_MESSAGES } from "$lib/constants/messages";
 import type { Backend, REPLRequest, REPLResponse } from "../types";
 
+import { browser } from "$app/environment";
 import type { PyodideInterface } from "https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs";
 import { backendPreferenceStore } from "$lib/stores";
 import type { BackendPreference } from "$lib/types";
@@ -32,6 +33,12 @@ function send(response: REPLResponse): void {
  * Initialize Pyodide and install packages (Needs FLASK Rework)
  */
 async function initialize(): Promise<void> {
+  if(browser) {
+    backendPreference = backendPreferenceStore.get()
+    console.log("The browser is available and the preference is: ", backendPreference)
+  } else {
+    console.log("The browser is not available")
+  }
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (isInitialized) {
       send({ type: "ready" });
@@ -97,6 +104,12 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
  * Execute Python code (no return value) (Needs FLASK Rework)
  */
 async function execCode(id: string, code: string): Promise<void> {
+  if(browser) {
+    backendPreference = backendPreferenceStore.get()
+    console.log("The browser is available and the preference is: ", backendPreference)
+  } else {
+    console.log("The browser is not available")
+  }
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
     try {
@@ -157,7 +170,8 @@ async function execCodeWithFlask(id: string, code: string): Promise <void> {
  * Evaluate Python expression and return JSON result
  * Note: _to_json helper is injected via REPL_SETUP_CODE (Needs FLASK Rework)
  */
-async function evalExpr(id: string, expr: string, backendPreference = null): Promise<void> {
+async function evalExpr(id: string, expr: string): Promise<void> {
+  if(browser) backendPreference = backendPreferenceStore.get()
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
 
diff --git a/src/lib/pyodide/pathsimRunner.ts b/src/lib/pyodide/pathsimRunner.ts
index 2e12cb7f..7ef0d57d 100644
--- a/src/lib/pyodide/pathsimRunner.ts
+++ b/src/lib/pyodide/pathsimRunner.ts
@@ -24,6 +24,7 @@ import {
 	generateListDefinition,
 	sanitizeName
 } from './codeBuilder';
+import type { BackendPreference } from '$lib/types';
 
 // Re-export sanitizeName for external use
 export { sanitizeName } from './codeBuilder';
@@ -1066,10 +1067,11 @@ function extractNodeParams(nodes: NodeInstance[]): Record<string, Record<string,
  */
 export async function validateGraphSimulation(
 	nodes: NodeInstance[],
-	codeContext: string
+	codeContext: string,
+	currentBackendPreference: null | BackendPreference
 ): Promise<ValidationResult> {
 	const nodeParams = extractNodeParams(nodes);
-	return validateGraphBridge(codeContext, nodeParams);
+	return validateGraphBridge(codeContext, nodeParams, currentBackendPreference);
 }
 
 export type { ValidationResult };
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 141149e7..f154eb73 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -762,7 +762,7 @@
 				let validation
 
 				// if(usingPyodide) {
-					validation = await validateGraphSimulation(nodes, codeContext);
+				validation = await validateGraphSimulation(nodes, codeContext, currentBackendPreference);
 				// } else {
 				// 	console.log("[Sending to Flask web server] The node registry is: ", nodeRegistry.getAll())
 				// 	let fetchedData = await fetch(getFlaskBackendUrl()+"/validateGraphSimulation", {

From 6bbee0451f05c083abb1aa8cd55be33c300b5572 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Mon, 19 Jan 2026 22:32:09 -0500
Subject: [PATCH 17/39] Marginal changes to backend preference

---
 src/lib/pyodide/backend/index.ts           |  5 ++--
 src/lib/pyodide/backend/pyodide/backend.ts | 20 +++++++++-----
 src/lib/pyodide/backend/pyodide/worker.ts  | 21 +++------------
 src/lib/pyodide/backend/registry.ts        | 31 +++++++++++++++-------
 src/lib/pyodide/bridge.ts                  | 12 ++++++---
 src/lib/pyodide/pathsimRunner.ts           |  1 +
 src/routes/+page.svelte                    |  2 +-
 7 files changed, 52 insertions(+), 40 deletions(-)

diff --git a/src/lib/pyodide/backend/index.ts b/src/lib/pyodide/backend/index.ts
index aea26ee5..7b221a28 100644
--- a/src/lib/pyodide/backend/index.ts
+++ b/src/lib/pyodide/backend/index.ts
@@ -34,6 +34,7 @@ export { PyodideBackend } from './pyodide/backend';
 import { getBackend } from './registry';
 import { backendState } from './state';
 import { consoleStore } from '$lib/stores/console';
+import type { BackendPreference } from '$lib/types';
 
 // Alias for backward compatibility
 export const replState = {
@@ -43,8 +44,8 @@ export const replState = {
 /**
  * Initialize the backend
  */
-export async function init(): Promise<void> {
-	const backend = getBackend();
+export async function init(currentBackendPreference: null | BackendPreference): Promise<void> {
+	const backend = getBackend(currentBackendPreference);
 
 	// Set up console output callbacks
 	backend.onStdout((value) => consoleStore.output(value));
diff --git a/src/lib/pyodide/backend/pyodide/backend.ts b/src/lib/pyodide/backend/pyodide/backend.ts
index 264b1408..e44c6065 100644
--- a/src/lib/pyodide/backend/pyodide/backend.ts
+++ b/src/lib/pyodide/backend/pyodide/backend.ts
@@ -9,6 +9,7 @@ import { backendState } from '../state';
 import { TIMEOUTS } from '$lib/constants/python';
 import { PROGRESS_MESSAGES, STATUS_MESSAGES } from '$lib/constants/messages';
 import type { BackendPreference } from '$lib/types';
+import { setWorkerBackendPreference } from './worker';
 
 interface PendingRequest {
 	resolve: (value: string | undefined) => void;
@@ -34,7 +35,7 @@ export class PyodideBackend implements Backend {
 	private messageId = 0;
 	private pendingRequests = new Map<string, PendingRequest>();
 	private isInitializing = false;
-	private backendPreference : BackendPreference = "pyodide";
+	private backendPreference : null | BackendPreference = "pyodide";
 
 	private streamState: StreamState = {
 		id: null,
@@ -51,7 +52,7 @@ export class PyodideBackend implements Backend {
 	// Lifecycle
 	// -------------------------------------------------------------------------
 
-	async init(): Promise<void> {
+	async init(currentBackendPreference : null | BackendPreference = null): Promise<void> {
 		const state = this.getState();
 
 		// Already initialized or loading - nothing to do
@@ -74,7 +75,9 @@ export class PyodideBackend implements Backend {
 		this.isInitializing = true;
 
 		try {
+			console.log("(backend.ts, init) The backend preference is: ", this.backendPreference)
 			this.worker = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' });
+			setWorkerBackendPreference(this.backendPreference)
 
 			this.worker.onmessage = (event: MessageEvent<REPLResponse>) => {
 				this.handleResponse(event.data);
@@ -170,10 +173,6 @@ export class PyodideBackend implements Backend {
 	getError(): string | null {
 		return this.getState().error;
 	}
-	
-	setBackendPreference(preference : BackendPreference): void {
-		this.backendPreference = preference
-	}
 
 	// -------------------------------------------------------------------------
 	// Execution
@@ -433,4 +432,13 @@ export class PyodideBackend implements Backend {
 
 		backendState.update((s) => ({ ...s, error: error || 'Unknown error' }));
 	}
+
+	setBackendPreference(currentBackendPreference : null | BackendPreference):void {
+		console.log("(backend.ts) Setting backend preference: ", currentBackendPreference)
+		this.backendPreference = currentBackendPreference
+	}
+
+	getBackendPreference(): null | BackendPreference {
+		return this.backendPreference
+	}
 }
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 22d99c6d..82d73993 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -9,9 +9,7 @@ import { PYODIDE_CDN_URL } from "$lib/constants/python";
 import { PROGRESS_MESSAGES, ERROR_MESSAGES } from "$lib/constants/messages";
 import type { Backend, REPLRequest, REPLResponse } from "../types";
 
-import { browser } from "$app/environment";
 import type { PyodideInterface } from "https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs";
-import { backendPreferenceStore } from "$lib/stores";
 import type { BackendPreference } from "$lib/types";
 import { getFlaskBackendUrl } from "$lib/utils/flaskRoutes";
 
@@ -33,12 +31,6 @@ function send(response: REPLResponse): void {
  * Initialize Pyodide and install packages (Needs FLASK Rework)
  */
 async function initialize(): Promise<void> {
-  if(browser) {
-    backendPreference = backendPreferenceStore.get()
-    console.log("The browser is available and the preference is: ", backendPreference)
-  } else {
-    console.log("The browser is not available")
-  }
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (isInitialized) {
       send({ type: "ready" });
@@ -104,12 +96,7 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
  * Execute Python code (no return value) (Needs FLASK Rework)
  */
 async function execCode(id: string, code: string): Promise<void> {
-  if(browser) {
-    backendPreference = backendPreferenceStore.get()
-    console.log("The browser is available and the preference is: ", backendPreference)
-  } else {
-    console.log("The browser is not available")
-  }
+  console.log("(worker.ts, execCode) The backend preference is: ", backendPreference)
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
     try {
@@ -170,8 +157,7 @@ async function execCodeWithFlask(id: string, code: string): Promise <void> {
  * Evaluate Python expression and return JSON result
  * Note: _to_json helper is injected via REPL_SETUP_CODE (Needs FLASK Rework)
  */
-async function evalExpr(id: string, expr: string): Promise<void> {
-  if(browser) backendPreference = backendPreferenceStore.get()
+async function evalExpr(id: string, expr: string, backendPreference = null): Promise<void> {
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
 
@@ -309,7 +295,8 @@ function stopStreaming(): void {
   streamingActive = false;
 }
 
-function setBackendPreference(preference : BackendPreference): void {
+export function setWorkerBackendPreference(preference : null | BackendPreference): void {
+  console.log(`(worker.ts) Setting the backend preference to: `, preference)
   backendPreference = preference
 }
 
diff --git a/src/lib/pyodide/backend/registry.ts b/src/lib/pyodide/backend/registry.ts
index e1eaaddc..e04cee9a 100644
--- a/src/lib/pyodide/backend/registry.ts
+++ b/src/lib/pyodide/backend/registry.ts
@@ -5,19 +5,24 @@
 
 import type { Backend } from './types';
 import { PyodideBackend } from './pyodide/backend';
+import type { BackendPreference } from '$lib/types';
 
 export type BackendType = 'pyodide' | 'local' | 'remote';
 
 let currentBackend: Backend | null = null;
-let currentBackendType: BackendType | null = null;
+let currentBackendType: BackendPreference | null = null;
 
 /**
  * Get the current backend, creating a Pyodide backend if none exists
  */
-export function getBackend(): Backend {
+export function getBackend(currentBackendPreference: null | BackendPreference = null): Backend {
+	console.log("(registry.ts) Current Backend Preference is: ", currentBackendPreference)
 	if (!currentBackend) {
-		currentBackend = createBackend('pyodide');
-		currentBackendType = 'pyodide';
+		if(currentBackendPreference == null) currentBackendPreference = "pyodide"
+		currentBackend = createBackend(currentBackendPreference);
+	}
+	if(getBackendType() !== currentBackendPreference) {
+		switchBackend(currentBackendPreference)
 	}
 	return currentBackend;
 }
@@ -25,13 +30,18 @@ export function getBackend(): Backend {
 /**
  * Create a backend by type
  */
-export function createBackend(type: BackendType): Backend {
+export function createBackend(type: null |  BackendPreference): Backend {
+	console.log("(registry.ts, createBackend) Current Backend Preference is: ", type)
 	switch (type) {
 		case 'pyodide':
+		case null:
 			return new PyodideBackend();
-		case 'local':
-		case 'remote':
-			throw new Error(`Backend type '${type}' not yet implemented`);
+		case 'flask':
+			let backend = new PyodideBackend()
+			backend.setBackendPreference("flask")
+			return backend
+		// case 'remote':
+		// 	throw new Error(`Backend type '${type}' not yet implemented`);
 		default:
 			throw new Error(`Unknown backend type: ${type}`);
 	}
@@ -41,7 +51,8 @@ export function createBackend(type: BackendType): Backend {
  * Switch to a different backend
  * Terminates the current backend before creating the new one
  */
-export function switchBackend(type: BackendType): Backend {
+export function switchBackend(type: BackendPreference | null): Backend {
+	console.log("(registry.ts, switchBackend) Switching backend type to ", type)
 	if (currentBackend) {
 		currentBackend.terminate();
 	}
@@ -53,7 +64,7 @@ export function switchBackend(type: BackendType): Backend {
 /**
  * Get the current backend type
  */
-export function getBackendType(): BackendType | null {
+export function getBackendType(): BackendPreference | null {
 	return currentBackendType;
 }
 
diff --git a/src/lib/pyodide/bridge.ts b/src/lib/pyodide/bridge.ts
index e9defab4..277a84c8 100644
--- a/src/lib/pyodide/bridge.ts
+++ b/src/lib/pyodide/bridge.ts
@@ -45,6 +45,7 @@ import {
 	STREAMING_STEP_EXPR,
 	STREAMING_STOP_CODE
 } from './pythonHelpers';
+import type { BackendPreference } from '$lib/types';
 
 // Result types
 export interface SimulationResult {
@@ -191,8 +192,9 @@ async function injectHelpers(): Promise<void> {
 /**
  * Initialize Pyodide
  */
-export async function initPyodide(): Promise<void> {
-	await initRepl();
+export async function initPyodide(currentBackendPreference: null | BackendPreference): Promise<void> {
+	console.log("(bridge, initPyodide) Current Backend Preference: ", currentBackendPreference)
+	await initRepl(currentBackendPreference);
 	await injectHelpers();
 }
 
@@ -510,11 +512,13 @@ export async function resetSimulation(): Promise<void> {
  */
 export async function validateGraph(
 	codeContext: string,
-	nodeParams: Record<string, Record<string, string>>
+	nodeParams: Record<string, Record<string, string>>,
+	currentBackendPreference: null | BackendPreference
 ): Promise<ValidationResult> {
 	const state = get(replState);
 	if (!state.initialized) {
-		await initPyodide();
+		console.log("(bridge) Current Backend Preference: ", currentBackendPreference)
+		await initPyodide(currentBackendPreference);
 	}
 
 	try {
diff --git a/src/lib/pyodide/pathsimRunner.ts b/src/lib/pyodide/pathsimRunner.ts
index 7ef0d57d..8f2c9944 100644
--- a/src/lib/pyodide/pathsimRunner.ts
+++ b/src/lib/pyodide/pathsimRunner.ts
@@ -1071,6 +1071,7 @@ export async function validateGraphSimulation(
 	currentBackendPreference: null | BackendPreference
 ): Promise<ValidationResult> {
 	const nodeParams = extractNodeParams(nodes);
+	console.log("(pathsimRunner) Backend preference passed in: ", currentBackendPreference)
 	return validateGraphBridge(codeContext, nodeParams, currentBackendPreference);
 }
 
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index f154eb73..f59fbec6 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -728,7 +728,7 @@
 		if (!pyodideReady && usingPyodide) {
 			try {
 				console.log("Initializing Pyodide")
-				await initPyodide();
+				await initPyodide("pyodide");
 			} catch (error) {
 				console.error('Failed to initialize Pyodide:', error);
 				return;

From 232ab1eedcbcecfcf69f22d2aa2c8c1df84b3c7e Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Tue, 20 Jan 2026 00:23:13 -0500
Subject: [PATCH 18/39] Reset the workers so that they check for the backend
 preference via the store, instead of the value being passed down! Also
 identified where the rror is thrown about a owrker not being initialized

---
 src/lib/pyodide/backend/index.ts           |  4 +-
 src/lib/pyodide/backend/pyodide/backend.ts |  8 ++--
 src/lib/pyodide/backend/pyodide/worker.ts  | 48 ++++++++++++++--------
 src/lib/pyodide/backend/registry.ts        |  5 ++-
 src/lib/pyodide/bridge.ts                  | 11 ++---
 src/lib/pyodide/pathsimRunner.ts           |  7 ++--
 6 files changed, 47 insertions(+), 36 deletions(-)

diff --git a/src/lib/pyodide/backend/index.ts b/src/lib/pyodide/backend/index.ts
index 7b221a28..6c9ec766 100644
--- a/src/lib/pyodide/backend/index.ts
+++ b/src/lib/pyodide/backend/index.ts
@@ -44,8 +44,8 @@ export const replState = {
 /**
  * Initialize the backend
  */
-export async function init(currentBackendPreference: null | BackendPreference): Promise<void> {
-	const backend = getBackend(currentBackendPreference);
+export async function init(): Promise<void> {
+	const backend = getBackend();
 
 	// Set up console output callbacks
 	backend.onStdout((value) => consoleStore.output(value));
diff --git a/src/lib/pyodide/backend/pyodide/backend.ts b/src/lib/pyodide/backend/pyodide/backend.ts
index e44c6065..8b42d510 100644
--- a/src/lib/pyodide/backend/pyodide/backend.ts
+++ b/src/lib/pyodide/backend/pyodide/backend.ts
@@ -9,7 +9,6 @@ import { backendState } from '../state';
 import { TIMEOUTS } from '$lib/constants/python';
 import { PROGRESS_MESSAGES, STATUS_MESSAGES } from '$lib/constants/messages';
 import type { BackendPreference } from '$lib/types';
-import { setWorkerBackendPreference } from './worker';
 
 interface PendingRequest {
 	resolve: (value: string | undefined) => void;
@@ -52,7 +51,7 @@ export class PyodideBackend implements Backend {
 	// Lifecycle
 	// -------------------------------------------------------------------------
 
-	async init(currentBackendPreference : null | BackendPreference = null): Promise<void> {
+	async init(): Promise<void> {
 		const state = this.getState();
 
 		// Already initialized or loading - nothing to do
@@ -77,12 +76,13 @@ export class PyodideBackend implements Backend {
 		try {
 			console.log("(backend.ts, init) The backend preference is: ", this.backendPreference)
 			this.worker = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' });
-			setWorkerBackendPreference(this.backendPreference)
 
 			this.worker.onmessage = (event: MessageEvent<REPLResponse>) => {
 				this.handleResponse(event.data);
 			};
 
+			console.log("The worker is: ", this.worker)
+
 			this.worker.onerror = (event) => {
 				backendState.update((s) => ({
 					...s,
@@ -92,7 +92,7 @@ export class PyodideBackend implements Backend {
 			};
 
 			// Send init message
-			this.sendRequest({ type: 'init' });
+			this.sendRequest({ type: 'init', backendPreference: this.backendPreference });
 
 			// Wait for ready
 			await new Promise<void>((resolve, reject) => {
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 82d73993..26d9c264 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -10,13 +10,13 @@ import { PROGRESS_MESSAGES, ERROR_MESSAGES } from "$lib/constants/messages";
 import type { Backend, REPLRequest, REPLResponse } from "../types";
 
 import type { PyodideInterface } from "https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs";
-import type { BackendPreference } from "$lib/types";
 import { getFlaskBackendUrl } from "$lib/utils/flaskRoutes";
+import { backendPreferenceStore } from "$lib/stores";
+import type { BackendPreference } from "$lib/types";
 
 let pyodide: PyodideInterface | null = null;
 let isInitialized = false;
-let backendPreference : null | BackendPreference = null
-let isFlaskInitialized = true;
+let backendPreference : null | BackendPreference = "pyodide"
 let streamingActive = false;
 const streamingCodeQueue: string[] = [];
 
@@ -30,7 +30,9 @@ function send(response: REPLResponse): void {
 /**
  * Initialize Pyodide and install packages (Needs FLASK Rework)
  */
-async function initialize(): Promise<void> {
+async function initialize(eventPreference : BackendPreference): Promise<void> {
+  console.log(`(worker.ts, initialize) Setting the backend preference to: ${eventPreference}`)
+  backendPreference = eventPreference
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (isInitialized) {
       send({ type: "ready" });
@@ -82,13 +84,18 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
   } else {
     /*	By default the isFlaskInitialized variable is true as we have the backend constantly running on a hosted server
      */
+    if (isInitialized) {
+      send({ type: "ready" });
+      return;
+    }
 
     console.log(
-      "We are ready, this is a flask web server so we don't concern with initialization"
+      "We are ready, this is a flask web server so we don't concern with initialization. Our only concern is whether the server is currently running."
     );
-    send({ type: "ready" });
 
-    return;
+    isInitialized = true;
+    console.log("Concluded intiialziation state change")
+    send({ type: "ready" });
   }
 }
 
@@ -96,9 +103,12 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
  * Execute Python code (no return value) (Needs FLASK Rework)
  */
 async function execCode(id: string, code: string): Promise<void> {
-  console.log("(worker.ts, execCode) The backend preference is: ", backendPreference)
+  console.log("(execCode) This backends preference is " + backendPreference)
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
-    if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+    if (!pyodide) {
+			console.log(`Within execCode() I have an uninitialized worker!`) // Debugging console
+      throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+    }
     try {
       await pyodide.runPythonAsync(code);
       send({ type: "ok", id });
@@ -159,7 +169,10 @@ async function execCodeWithFlask(id: string, code: string): Promise <void> {
  */
 async function evalExpr(id: string, expr: string, backendPreference = null): Promise<void> {
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
-    if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+    if (!pyodide) {
+			console.log(`Within evalExpr() I have an uninitialized worker!`) // Debugging console
+      throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+    }
 
     try {
       const result = await pyodide.runPythonAsync(`
@@ -223,7 +236,10 @@ async function evalExprWithFlask(id: string, expr: string) : Promise<void> {
  * Runs autonomously until done or stopped (Needs FLASK Rework)
  */
 async function runStreamingLoop(id: string, expr: string): Promise<void> {
-  if (!pyodide) throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+  if (!pyodide) {
+			console.log(`Within runStreamingLoop() I have an uninitialized worker!`) // Debugging console
+      throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
+  }
 
   streamingActive = true;
   // Clear any stale code from previous runs
@@ -295,11 +311,6 @@ function stopStreaming(): void {
   streamingActive = false;
 }
 
-export function setWorkerBackendPreference(preference : null | BackendPreference): void {
-  console.log(`(worker.ts) Setting the backend preference to: `, preference)
-  backendPreference = preference
-}
-
 // Handle messages from main thread
 self.onmessage = async (event: MessageEvent<REPLRequest>) => {
   const { type } = event.data;
@@ -308,10 +319,13 @@ self.onmessage = async (event: MessageEvent<REPLRequest>) => {
   const code = "code" in event.data ? event.data.code : undefined;
   const expr = "expr" in event.data ? event.data.expr : undefined;
 
+  const preference = "backendPreference" in event.data ? event.data.backendPreference : "pyodide"
+
   try {
     switch (type) {
       case "init":
-        await initialize();
+        console.log("Event Data is: ", event.data)
+        await initialize(preference);
         break;
 
       case "exec":
diff --git a/src/lib/pyodide/backend/registry.ts b/src/lib/pyodide/backend/registry.ts
index e04cee9a..2b5346df 100644
--- a/src/lib/pyodide/backend/registry.ts
+++ b/src/lib/pyodide/backend/registry.ts
@@ -6,6 +6,7 @@
 import type { Backend } from './types';
 import { PyodideBackend } from './pyodide/backend';
 import type { BackendPreference } from '$lib/types';
+import { backendPreferenceStore } from '$lib/stores';
 
 export type BackendType = 'pyodide' | 'local' | 'remote';
 
@@ -15,8 +16,8 @@ let currentBackendType: BackendPreference | null = null;
 /**
  * Get the current backend, creating a Pyodide backend if none exists
  */
-export function getBackend(currentBackendPreference: null | BackendPreference = null): Backend {
-	console.log("(registry.ts) Current Backend Preference is: ", currentBackendPreference)
+export function getBackend(): Backend {
+	let currentBackendPreference = backendPreferenceStore.get()
 	if (!currentBackend) {
 		if(currentBackendPreference == null) currentBackendPreference = "pyodide"
 		currentBackend = createBackend(currentBackendPreference);
diff --git a/src/lib/pyodide/bridge.ts b/src/lib/pyodide/bridge.ts
index 277a84c8..56304351 100644
--- a/src/lib/pyodide/bridge.ts
+++ b/src/lib/pyodide/bridge.ts
@@ -192,9 +192,8 @@ async function injectHelpers(): Promise<void> {
 /**
  * Initialize Pyodide
  */
-export async function initPyodide(currentBackendPreference: null | BackendPreference): Promise<void> {
-	console.log("(bridge, initPyodide) Current Backend Preference: ", currentBackendPreference)
-	await initRepl(currentBackendPreference);
+export async function initPyodide(): Promise<void> {
+	await initRepl();
 	await injectHelpers();
 }
 
@@ -512,13 +511,11 @@ export async function resetSimulation(): Promise<void> {
  */
 export async function validateGraph(
 	codeContext: string,
-	nodeParams: Record<string, Record<string, string>>,
-	currentBackendPreference: null | BackendPreference
+	nodeParams: Record<string, Record<string, string>>
 ): Promise<ValidationResult> {
 	const state = get(replState);
 	if (!state.initialized) {
-		console.log("(bridge) Current Backend Preference: ", currentBackendPreference)
-		await initPyodide(currentBackendPreference);
+		await initPyodide();
 	}
 
 	try {
diff --git a/src/lib/pyodide/pathsimRunner.ts b/src/lib/pyodide/pathsimRunner.ts
index 8f2c9944..4cadb8f8 100644
--- a/src/lib/pyodide/pathsimRunner.ts
+++ b/src/lib/pyodide/pathsimRunner.ts
@@ -25,6 +25,7 @@ import {
 	sanitizeName
 } from './codeBuilder';
 import type { BackendPreference } from '$lib/types';
+import { backendPreferenceStore } from '$lib/stores';
 
 // Re-export sanitizeName for external use
 export { sanitizeName } from './codeBuilder';
@@ -1067,12 +1068,10 @@ function extractNodeParams(nodes: NodeInstance[]): Record<string, Record<string,
  */
 export async function validateGraphSimulation(
 	nodes: NodeInstance[],
-	codeContext: string,
-	currentBackendPreference: null | BackendPreference
+	codeContext: string
 ): Promise<ValidationResult> {
 	const nodeParams = extractNodeParams(nodes);
-	console.log("(pathsimRunner) Backend preference passed in: ", currentBackendPreference)
-	return validateGraphBridge(codeContext, nodeParams, currentBackendPreference);
+	return validateGraphBridge(codeContext, nodeParams);
 }
 
 export type { ValidationResult };

From 18da70e0d4a1118ffa78459d164a6bf199f3b6b7 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Tue, 20 Jan 2026 00:24:47 -0500
Subject: [PATCH 19/39] Achevied a different evaluation result which is amazing

---
 src/lib/pyodide/backend/pyodide/worker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 26d9c264..fbe9f069 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -167,7 +167,7 @@ async function execCodeWithFlask(id: string, code: string): Promise <void> {
  * Evaluate Python expression and return JSON result
  * Note: _to_json helper is injected via REPL_SETUP_CODE (Needs FLASK Rework)
  */
-async function evalExpr(id: string, expr: string, backendPreference = null): Promise<void> {
+async function evalExpr(id: string, expr: string): Promise<void> {
   if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
     if (!pyodide) {
 			console.log(`Within evalExpr() I have an uninitialized worker!`) // Debugging console

From 762e44c8bffc52aa0a5824e07e8422b4debb61bc Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 21 Jan 2026 10:49:17 -0500
Subject: [PATCH 20/39] Changed the preference switcher so it interacts with
 switchBackend(), seem to have finished eval and exec. Trying to figure out
 how to run streaming with flask now

---
 src/lib/pyodide/backend/pyodide/backend.ts |   1 +
 src/lib/pyodide/backend/pyodide/worker.ts  | 298 +++++++++++++--------
 src/lib/stores/backendPreference.ts        |   8 +-
 3 files changed, 194 insertions(+), 113 deletions(-)

diff --git a/src/lib/pyodide/backend/pyodide/backend.ts b/src/lib/pyodide/backend/pyodide/backend.ts
index 8b42d510..0978584e 100644
--- a/src/lib/pyodide/backend/pyodide/backend.ts
+++ b/src/lib/pyodide/backend/pyodide/backend.ts
@@ -235,6 +235,7 @@ export class PyodideBackend implements Backend {
 					try {
 						resolve(JSON.parse(value) as T);
 					} catch {
+						console.log("Error in evaluating the expression:", value)
 						reject(new Error(`Failed to parse eval result: ${value}`));
 					}
 				},
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index fbe9f069..90062374 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -11,12 +11,12 @@ import type { Backend, REPLRequest, REPLResponse } from "../types";
 
 import type { PyodideInterface } from "https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs";
 import { getFlaskBackendUrl } from "$lib/utils/flaskRoutes";
-import { backendPreferenceStore } from "$lib/stores";
+import { backendPreferenceStore, consoleStore } from "$lib/stores";
 import type { BackendPreference } from "$lib/types";
 
 let pyodide: PyodideInterface | null = null;
 let isInitialized = false;
-let backendPreference : null | BackendPreference = "pyodide"
+let backendPreference: null | BackendPreference = null;
 let streamingActive = false;
 const streamingCodeQueue: string[] = [];
 
@@ -30,10 +30,13 @@ function send(response: REPLResponse): void {
 /**
  * Initialize Pyodide and install packages (Needs FLASK Rework)
  */
-async function initialize(eventPreference : BackendPreference): Promise<void> {
-  console.log(`(worker.ts, initialize) Setting the backend preference to: ${eventPreference}`)
-  backendPreference = eventPreference
-  if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
+async function initialize(eventPreference: BackendPreference): Promise<void> {
+  console.log(
+    `(worker.ts, initialize) Setting the backend preference to: ${eventPreference}`,
+  );
+  backendPreference = eventPreference;
+  if (!backendPreference || backendPreference == "pyodide") {
+    // Default to pyodide use
     if (isInitialized) {
       send({ type: "ready" });
       return;
@@ -90,11 +93,11 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
     }
 
     console.log(
-      "We are ready, this is a flask web server so we don't concern with initialization. Our only concern is whether the server is currently running."
+      "We are ready, this is a flask web server so we don't concern with initialization. Our only concern is whether the server is currently running.",
     );
 
     isInitialized = true;
-    console.log("Concluded intiialziation state change")
+    console.log("Concluded intiialziation state change");
     send({ type: "ready" });
   }
 }
@@ -103,10 +106,11 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
  * Execute Python code (no return value) (Needs FLASK Rework)
  */
 async function execCode(id: string, code: string): Promise<void> {
-  console.log("(execCode) This backends preference is " + backendPreference)
-  if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
+  console.log("(execCode) This backends preference is " + backendPreference);
+  if (!backendPreference || backendPreference == "pyodide") {
+    // Default to pyodide use
     if (!pyodide) {
-			console.log(`Within execCode() I have an uninitialized worker!`) // Debugging console
+      console.log(`Within execCode() I have an uninitialized worker!`); // Debugging console
       throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
     }
     try {
@@ -127,40 +131,27 @@ traceback.format_exc()
       send({ type: "error", id, error: errorMsg, traceback });
     }
   } else {
-    return execCodeWithFlask(id, code)
+    return execCodeWithFlask(id, code);
   }
 }
 
-async function execCodeWithFlask(id: string, code: string): Promise <void> {
-    try {
-      let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({code: code})
-      }).then(
-        (res) => res.json()
-      );
-      if (data.success) {
-        send({ type: "ok", id });
-      } else {
-        throw Error(data.error);
-      }
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      let traceback: string | undefined;
-      try {
-        traceback = (
-          await fetch(getFlaskBackendUrl() + "/traceback")
-            .then((res) => res.json())
-            .then((res) => res.json)
-        ).traceback as string;
-      } catch (error) {
-        // Ignore as in the Pyodide framework
-      }
-      send({ type: "error", id, error: errorMsg, traceback });
+async function execCodeWithFlask(id: string, code: string): Promise<void> {
+  try {
+    let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ code: code }),
+    }).then((res) => res.json());
+    if (data.success) {
+      send({ type: "ok", id });
+    } else {
+      throw Error(data.error);
     }
+  } catch (error) {
+    return runTracebackWithFlask(id, error);
+  }
 }
 
 /**
@@ -168,9 +159,10 @@ async function execCodeWithFlask(id: string, code: string): Promise <void> {
  * Note: _to_json helper is injected via REPL_SETUP_CODE (Needs FLASK Rework)
  */
 async function evalExpr(id: string, expr: string): Promise<void> {
-  if (!backendPreference || backendPreference == "pyodide") { // Default to pyodide use
+  if (!backendPreference || backendPreference == "pyodide") {
+    // Default to pyodide use
     if (!pyodide) {
-			console.log(`Within evalExpr() I have an uninitialized worker!`) // Debugging console
+      console.log(`Within evalExpr() I have an uninitialized worker!`); // Debugging console
       throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
     }
 
@@ -179,7 +171,11 @@ async function evalExpr(id: string, expr: string): Promise<void> {
 _eval_result = ${expr}
 json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
 		`);
-
+      console.log(
+        "\n\n(Pyodide) The evaluated result from evaluating the expression: ",
+        result,
+        "\n\n",
+      );
       send({ type: "value", id, value: result as string });
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -195,64 +191,135 @@ traceback.format_exc()
       send({ type: "error", id, error: errorMsg, traceback });
     }
   } else {
-    return evalExprWithFlask(id, expr)
+    return evalExprWithFlask(id, expr);
   }
 }
 
-async function evalExprWithFlask(id: string, expr: string) : Promise<void> {
-    try {
-      let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({expr: expr})
-      }).then(
-        (res) => res.json()
+async function evalExprWithFlask(id: string, expr: string): Promise<void> {
+  try {
+    let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ expr: expr }),
+    }).then((res) => res.json());
+
+    if (data.success) {
+      console.log(
+        "\n\n(Flask) The evaluated result from evaluating the expression: ",
+        JSON.stringify(data.result),
+        "\n\n",
       );
-      
-      if (data.success) {
-        send({ type: "value", id, value: data.result as string });
-      } else {
-        throw Error(data.error);
-      }
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      let traceback: string | undefined;
-      try {
-        traceback = (
-          await fetch(getFlaskBackendUrl() + "/traceback")
-            .then((res) => res.json())
-            .then((res) => res.json)
-        ).traceback as string;
-      } catch (error) {
-        // Ignore as in the Pyodide framework
-      }
-      send({ type: "error", id, error: errorMsg, traceback });
+      send({ type: "value", id, value: JSON.stringify(data.result) as string });
+    } else {
+      throw Error(data.error);
     }
+  } catch (error) {
+    return runTracebackWithFlask(id, error);
+  }
 }
+
 /**
  * Run streaming loop - steps generator continuously and posts results
  * Runs autonomously until done or stopped (Needs FLASK Rework)
  */
 async function runStreamingLoop(id: string, expr: string): Promise<void> {
-  if (!pyodide) {
-			console.log(`Within runStreamingLoop() I have an uninitialized worker!`) // Debugging console
+  if (backendPreference == "pyodide" || !backendPreference) {
+    if (!pyodide) {
+      console.log(`Within runStreamingLoop() I have an uninitialized worker!`); // Debugging console
       throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
-  }
+    }
+
+    streamingActive = true;
+    // Clear any stale code from previous runs
+    streamingCodeQueue.length = 0;
+
+    try {
+      while (streamingActive) {
+        // Execute any queued code first (for runtime parameter changes, events, etc.)
+        // Errors in queued code are reported but don't stop the simulation
+        while (streamingCodeQueue.length > 0) {
+          const code = streamingCodeQueue.shift()!;
+          try {
+            await pyodide.runPythonAsync(code);
+          } catch (error) {
+            const errorMsg =
+              error instanceof Error ? error.message : String(error);
+            send({ type: "stderr", value: `Stream exec error: ${errorMsg}` });
+          }
+        }
+
+        // Step the generator
+        const result = await pyodide.runPythonAsync(`
+_eval_result = ${expr}
+json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
+			`);
+
+        // Parse result
+        const parsed = JSON.parse(result as string);
 
-  streamingActive = true;
-  // Clear any stale code from previous runs
-  streamingCodeQueue.length = 0;
+        // Check if stopped during Python execution - still send final data
+        if (!streamingActive) {
+          if (!parsed.done && parsed.result) {
+            send({ type: "stream-data", id, value: result as string });
+          }
+          break;
+        }
+
+        // Check if simulation completed
+        if (parsed.done) {
+          break;
+        }
 
+        // Send result and continue
+        send({ type: "stream-data", id, value: result as string });
+      }
+    } catch (error) {
+      // Traceback general error catching....
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      let traceback: string | undefined;
+      try {
+        traceback = (await pyodide.runPythonAsync(`
+import traceback
+traceback.format_exc()
+			`)) as string;
+      } catch {
+        // Ignore
+      }
+      send({ type: "error", id, error: errorMsg, traceback });
+    } finally {
+      streamingActive = false;
+      // Always send done when loop ends (whether completed, stopped, or error)
+      send({ type: "stream-done", id });
+    }
+  } else {
+    return runStreamingLoopWithFlask(id, expr);
+  }
+}
+
+async function runStreamingLoopWithFlask(id: string, expr: string) {
   try {
+    streamingActive = true;
+
+    streamingCodeQueue.length = 0;
     while (streamingActive) {
       // Execute any queued code first (for runtime parameter changes, events, etc.)
       // Errors in queued code are reported but don't stop the simulation
+      consoleStore.info("Evaluating streaming code queue, which has length of: " + streamingCodeQueue.length)
       while (streamingCodeQueue.length > 0) {
         const code = streamingCodeQueue.shift()!;
         try {
-          await pyodide.runPythonAsync(code);
+          // Simply sending requests to the Flask api to execute code, we only really care if errors are produced so we
+          // don't handle any data response
+
+          await fetch(getFlaskBackendUrl() + "/execute-code", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ code: code }),
+          });
         } catch (error) {
           const errorMsg =
             error instanceof Error ? error.message : String(error);
@@ -260,50 +327,60 @@ async function runStreamingLoop(id: string, expr: string): Promise<void> {
         }
       }
 
-      // Step the generator
-      const result = await pyodide.runPythonAsync(`
-_eval_result = ${expr}
-json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
-			`);
+      consoleStore.info("Streaming code queue has reached a length of 0")
 
-      // Parse result
-      const parsed = JSON.parse(result as string);
+      let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ expr: expr }),
+      }).then((res) => res.json());
 
-      // Check if stopped during Python execution - still send final data
       if (!streamingActive) {
-        if (!parsed.done && parsed.result) {
-          send({ type: "stream-data", id, value: result as string });
+        if (!data.done && data.result) {
+          send({
+            type: "stream-data",
+            id,
+            value: JSON.stringify(data.result) as string,
+          });
         }
         break;
       }
 
-      // Check if simulation completed
-      if (parsed.done) {
+      if (data.done) {
         break;
       }
 
-      // Send result and continue
-      send({ type: "stream-data", id, value: result as string });
+      send({
+        type: "stream-data",
+        id,
+        value: JSON.stringify(data.result) as string,
+      });
     }
   } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    let traceback: string | undefined;
-    try {
-      traceback = (await pyodide.runPythonAsync(`
-import traceback
-traceback.format_exc()
-			`)) as string;
-    } catch {
-      // Ignore
-    }
-    send({ type: "error", id, error: errorMsg, traceback });
+    return runTracebackWithFlask(id, error);
   } finally {
     streamingActive = false;
-    // Always send done when loop ends (whether completed, stopped, or error)
     send({ type: "stream-done", id });
   }
 }
 
+async function runTracebackWithFlask(id: string, error: unknown) {
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  let traceback: string | undefined;
+  try {
+    traceback = (
+      await fetch(getFlaskBackendUrl() + "/traceback")
+        .then((res) => res.json())
+        .then((res) => res.json)
+    ).traceback as string;
+  } catch (error) {
+    // Ignore as in the Pyodide framework
+  }
+  send({ type: "error", id, error: errorMsg, traceback });
+}
+
 /**
  * Stop streaming loop
  */
@@ -319,12 +396,15 @@ self.onmessage = async (event: MessageEvent<REPLRequest>) => {
   const code = "code" in event.data ? event.data.code : undefined;
   const expr = "expr" in event.data ? event.data.expr : undefined;
 
-  const preference = "backendPreference" in event.data ? event.data.backendPreference : "pyodide"
+  const preference =
+    "backendPreference" in event.data
+      ? event.data.backendPreference
+      : "pyodide";
 
   try {
     switch (type) {
       case "init":
-        console.log("Event Data is: ", event.data)
+        console.log("Event Data is: ", event.data);
         await initialize(preference);
         break;
 
diff --git a/src/lib/stores/backendPreference.ts b/src/lib/stores/backendPreference.ts
index 5f6f66cc..ff01e7d6 100644
--- a/src/lib/stores/backendPreference.ts
+++ b/src/lib/stores/backendPreference.ts
@@ -6,6 +6,7 @@
 
 import { writable } from 'svelte/store';
 import { browser } from '$app/environment';
+import { switchBackend } from '$lib/pyodide';
 
 export type BackendPreference = 'pyodide' | 'flask';
 
@@ -40,11 +41,10 @@ export const backendPreferenceStore = {
 	 * Toggle between a preference for flask or pyodide
 	 */
 	toggle(): void {
+		console.log(`Value (Before), ${this.get()}`)
 		backendPreference.update((current) => (current === 'pyodide' ? 'flask' : 'pyodide'));
-		if(typeof window !== "undefined") {
-			// To avoid complications with the initialization state of the Pyodide Backend class I will just reload the page
-			window.location.reload()
-		}
+		console.log(`Value (After), ${this.get()}`)
+		switchBackend(this.get())
 	},
 
 	/**

From 7279693a7fe7b258638a080ee17185ef07c3dacd Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 21 Jan 2026 14:13:14 -0500
Subject: [PATCH 21/39] Any remaining miscellaneous changes

---
 src/backend.py                            | 10 ++--
 src/lib/pyodide/backend/pyodide/worker.ts | 61 ++++++++++++++++++-----
 src/routes/+page.svelte                   |  5 +-
 3 files changed, 57 insertions(+), 19 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index b9bb2efd..2f53165d 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -77,11 +77,12 @@ def execute_code():
             error_output = stderr_capture.getvalue()
 
             if error_output:
-                return jsonify({"success": False, "error": error_output}), 400
+                return jsonify({"success": False, "error": error_output})
             
             return jsonify(
                 {
-                    "success": True
+                    "success": True,
+                    "output": output
                 }
             )
 
@@ -117,12 +118,13 @@ def evaluate_expression():
             error_output = stderr_capture.getvalue()
 
             if error_output:
-                return jsonify({"success": False, "error": error_output}), 400
+                return jsonify({"success": False, "error": error_output})
             
             return jsonify(
                 {
                     "success": True,
-                    "result": result
+                    "result": result,
+                    "output": output
                 }
             )
 
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 90062374..e73a810a 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -34,7 +34,7 @@ async function initialize(eventPreference: BackendPreference): Promise<void> {
   console.log(
     `(worker.ts, initialize) Setting the backend preference to: ${eventPreference}`,
   );
-  backendPreference = eventPreference;
+  backendPreference = eventPreference as BackendPreference;
   if (!backendPreference || backendPreference == "pyodide") {
     // Default to pyodide use
     if (isInitialized) {
@@ -97,7 +97,8 @@ print(f"PathSim {pathsim.__version__} loaded successfully")
     );
 
     isInitialized = true;
-    console.log("Concluded intiialziation state change");
+    send({ type: "stdout", value: "Your backend preference has been set to a Flask web server, initialization has already occured"})
+    console.log("Concluded intialziation state change");
     send({ type: "ready" });
   }
 }
@@ -144,12 +145,17 @@ async function execCodeWithFlask(id: string, code: string): Promise<void> {
       },
       body: JSON.stringify({ code: code }),
     }).then((res) => res.json());
-    if (data.success) {
+    if (data.success && !data.error) {
+      if(data.output) {
+        send({type: "stdout", value: data.output })
+      }
       send({ type: "ok", id });
     } else {
       throw Error(data.error);
     }
-  } catch (error) {
+  } catch (error) { 
+    // This traceback may actually be unnecessary in all Flaskc ases,
+    // unless there is someway that the error output doesn't fully capture all the relevant information
     return runTracebackWithFlask(id, error);
   }
 }
@@ -204,8 +210,10 @@ async function evalExprWithFlask(id: string, expr: string): Promise<void> {
       },
       body: JSON.stringify({ expr: expr }),
     }).then((res) => res.json());
-
-    if (data.success) {
+    if (data.success && !data.error) {
+      if(data.output) {
+        send({type: "stdout", value: data.output })
+      }
       console.log(
         "\n\n(Flask) The evaluated result from evaluating the expression: ",
         JSON.stringify(data.result),
@@ -273,6 +281,10 @@ json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
         }
 
         // Send result and continue
+        console.log(
+          "(Pyodide) Done streaming data, the final value is....",
+          JSON.parse(result as string)
+        );
         send({ type: "stream-data", id, value: result as string });
       }
     } catch (error) {
@@ -306,20 +318,24 @@ async function runStreamingLoopWithFlask(id: string, expr: string) {
     while (streamingActive) {
       // Execute any queued code first (for runtime parameter changes, events, etc.)
       // Errors in queued code are reported but don't stop the simulation
-      consoleStore.info("Evaluating streaming code queue, which has length of: " + streamingCodeQueue.length)
       while (streamingCodeQueue.length > 0) {
         const code = streamingCodeQueue.shift()!;
         try {
           // Simply sending requests to the Flask api to execute code, we only really care if errors are produced so we
           // don't handle any data response
 
-          await fetch(getFlaskBackendUrl() + "/execute-code", {
+          let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
             },
             body: JSON.stringify({ code: code }),
-          });
+          }).then(res => res.json());
+          if(data.success && !data.error && data.output) {
+            send({ type: "stdout", value: data.output })
+          } else {
+            throw Error(data.error)
+          }
         } catch (error) {
           const errorMsg =
             error instanceof Error ? error.message : String(error);
@@ -327,8 +343,6 @@ async function runStreamingLoopWithFlask(id: string, expr: string) {
         }
       }
 
-      consoleStore.info("Streaming code queue has reached a length of 0")
-
       let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
         method: "POST",
         headers: {
@@ -337,8 +351,23 @@ async function runStreamingLoopWithFlask(id: string, expr: string) {
         body: JSON.stringify({ expr: expr }),
       }).then((res) => res.json());
 
+      if (data.success && !data.error) {
+        if(data.output) {
+          send({ type: "stdout", value: data.output })
+        }
+        data = data.result;
+      } else {
+        throw Error(data.error);
+      }
+
+      // console.log("Resultant returned is: ", data)
+
       if (!streamingActive) {
         if (!data.done && data.result) {
+          // console.log("Still streaming data....")
+          if(data.result) {
+            console.log("(Flask) Still streaming data, but this value was returned: ", data.result)
+          }
           send({
             type: "stream-data",
             id,
@@ -352,16 +381,22 @@ async function runStreamingLoopWithFlask(id: string, expr: string) {
         break;
       }
 
+      console.log(
+        "(Flask) Done streaming data, the final value is....",
+        data,
+      );
+
       send({
         type: "stream-data",
         id,
-        value: JSON.stringify(data.result) as string,
+        value: JSON.stringify(data) as string,
       });
     }
   } catch (error) {
     return runTracebackWithFlask(id, error);
   } finally {
     streamingActive = false;
+    console.log("Have completely finished streaming!");
     send({ type: "stream-done", id });
   }
 }
@@ -405,7 +440,7 @@ self.onmessage = async (event: MessageEvent<REPLRequest>) => {
     switch (type) {
       case "init":
         console.log("Event Data is: ", event.data);
-        await initialize(preference);
+        await initialize(preference as BackendPreference);
         break;
 
       case "exec":
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index f59fbec6..32f02e84 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -728,7 +728,7 @@
 		if (!pyodideReady && usingPyodide) {
 			try {
 				console.log("Initializing Pyodide")
-				await initPyodide("pyodide");
+				await initPyodide();
 			} catch (error) {
 				console.error('Failed to initialize Pyodide:', error);
 				return;
@@ -762,7 +762,7 @@
 				let validation
 
 				// if(usingPyodide) {
-				validation = await validateGraphSimulation(nodes, codeContext, currentBackendPreference);
+				validation = await validateGraphSimulation(nodes, codeContext);
 				// } else {
 				// 	console.log("[Sending to Flask web server] The node registry is: ", nodeRegistry.getAll())
 				// 	let fetchedData = await fetch(getFlaskBackendUrl()+"/validateGraphSimulation", {
@@ -810,6 +810,7 @@
 			// Run streaming simulation
 			try {
 				const events = eventStore.toJSON();
+				console.log("-- Starting STREAMING --")
 				await runGraphStreamingSimulation(
 					nodes,
 					connections,

From 3ad79765a50f261cdb182847ef719e348d24098c Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 09:50:13 -0500
Subject: [PATCH 22/39] Working on Flask Backend type

---
 src/lib/pyodide/backend/flask/backend.ts   | 30 ++++++++++++++++++++++
 src/lib/pyodide/backend/pyodide/backend.ts |  1 -
 src/lib/pyodide/backend/pyodide/worker.ts  |  4 ++-
 src/lib/pyodide/pythonHelpers.ts           |  6 ++++-
 4 files changed, 38 insertions(+), 3 deletions(-)
 create mode 100644 src/lib/pyodide/backend/flask/backend.ts

diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
new file mode 100644
index 00000000..a7ab93ae
--- /dev/null
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -0,0 +1,30 @@
+/**
+ * Flask Backend Implementation
+ *
+ * Runs Python code via API rqeuests to a Flask web server
+ * Supports streaming with code injection between generator steps.
+ */
+
+import { backendState } from "../state";
+import type { Backend, BackendState } from "../types";
+
+export class FlaskBackend implements Backend {
+    
+    async init() : Promise<void> {
+
+    }
+
+    terminate(): void {
+
+    }
+
+    getState(): BackendState {
+        return backendState.get()
+    }
+
+    subscribe(callback: (state: BackendState) => void): () => void {
+        return backendState.subscribe(callback)
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/lib/pyodide/backend/pyodide/backend.ts b/src/lib/pyodide/backend/pyodide/backend.ts
index 0978584e..ce6b3da0 100644
--- a/src/lib/pyodide/backend/pyodide/backend.ts
+++ b/src/lib/pyodide/backend/pyodide/backend.ts
@@ -3,7 +3,6 @@
  * Implements the Backend interface using Pyodide in a Web Worker
  */
 
-import { get } from 'svelte/store';
 import type { Backend, BackendState, REPLRequest, REPLResponse, REPLErrorResponse } from '../types';
 import { backendState } from '../state';
 import { TIMEOUTS } from '$lib/constants/python';
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index b87236bf..4b02558b 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -277,6 +277,8 @@ async function runStreamingLoop(id: string, expr: string): Promise<void> {
           }
         }
 
+        console.log(`(Pyodide) The expression being sent is: `, expr)
+
         // Step the generator
         const result = await pyodide.runPythonAsync(`
 _eval_result = ${expr}
@@ -350,7 +352,7 @@ async function runStreamingLoopWithFlask(id: string, expr: string) {
             },
             body: JSON.stringify({ code: code }),
           }).then(res => res.json());
-          if(data.success && !data.error && data.output) {
+          if(data.success && data.output) {
             send({ type: "stdout", value: data.output })
           } else {
             throw Error(data.error)
diff --git a/src/lib/pyodide/pythonHelpers.ts b/src/lib/pyodide/pythonHelpers.ts
index 6e2a9842..180a43d4 100644
--- a/src/lib/pyodide/pythonHelpers.ts
+++ b/src/lib/pyodide/pythonHelpers.ts
@@ -49,7 +49,9 @@ def _extract_scope_data(blocks, node_id_map, incremental=False):
             if block_name == 'Scope':
                 try:
                     data = block.read(incremental=incremental)
-                    if data is not None:
+                    if type(data) is tuple and data[0] is None and data[1] is None:
+                        pass
+                    elif data is not None:
                         time_arr, signals = data
                         labels = list(block.labels) if hasattr(block, 'labels') and block.labels else []
                         scope_data[block_id] = {
@@ -58,6 +60,8 @@ def _extract_scope_data(blocks, node_id_map, incremental=False):
                             'labels': labels
                         }
                 except Exception as e:
+                    print("Data: ", data)
+                    print("Block ID: ", block_id)
                     print(f"Error reading Scope: {e}")
             elif block_name == 'Subsystem':
                 if hasattr(block, 'blocks'):

From 7eb0aaa0ebef86bc274d1a6d39b1ee156e828a40 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 09:50:53 -0500
Subject: [PATCH 23/39] Removed stdlib packages in requirements.txt to avoid
 error with pip install -r

---
 requirements.txt | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index cb241c98..74efc233 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,8 +3,5 @@ Flask>=3.1.1
 flask-cors>=6.0.1
 
 numpy
-gc
 pathsim
-pathsim_chem
-io
-contextlib
\ No newline at end of file
+pathsim_chem
\ No newline at end of file

From 3514e2127782b2fb3af354983b7e9c4770d52928 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 11:31:28 -0500
Subject: [PATCH 24/39] Set up the proper flask backend architecture for
 execution and evaluation. Still need to implement basic streaming option and
 also work on removing the flask snippets that remain in worker.ts

---
 src/backend.py                           |   8 +-
 src/lib/pyodide/backend/flask/backend.ts | 413 ++++++++++++++++++++++-
 src/lib/pyodide/backend/registry.ts      |   7 +-
 src/lib/pyodide/bridge.ts                |   1 -
 4 files changed, 411 insertions(+), 18 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 2f53165d..170f95bf 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -38,11 +38,12 @@
              } 
          })
 else:
+    print("We are not in production...")
     CORS(
         app, 
-        reosurces={
+        resources={
             r"/*": {""
-                "origins": {"origins": ["http://localhost:5173", "http://localhost:3000"]}
+                "origins": ["http://localhost:5173", "http://localhost:3000"]
             }
         },
         supports_credentials=True
@@ -144,6 +145,9 @@ def check_traceback():
     except Exception as e:
         return jsonify({"success": False, "error": f"Server-side error: {e}"})
 
+@app.route("/streamData", methods=["POST"])
+def stream_data():
+    pass
 # @app.route("/runGraphStreamingSimulation", methods=["POST"])
 # def runGraphStreamingSimulation():
 #     try:
diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index a7ab93ae..70483239 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -3,28 +3,417 @@
  *
  * Runs Python code via API rqeuests to a Flask web server
  * Supports streaming with code injection between generator steps.
+ * The pyodide backend has a general handler function which handles the responses that a Web Worker provides
+ * however, we directly handle data given the fact that we don't instantiate a worker and use a Flask web server
  */
 
+import { STATUS_MESSAGES } from "$lib/constants/messages";
+import { TIMEOUTS } from "$lib/constants/python";
+import { getFlaskBackendUrl } from "$lib/utils/flaskRoutes";
 import { backendState } from "../state";
-import type { Backend, BackendState } from "../types";
+import type {
+	Backend,
+	BackendState,
+	REPLErrorResponse,
+	REPLResponse,
+} from "../types";
+
+interface PendingRequest {
+	resolve: (value: string | undefined) => void;
+	reject: (error: Error) => void;
+	timeoutId: ReturnType<typeof setTimeout>;
+}
+
+interface StreamState {
+	id: string | null;
+	onData: ((data: unknown) => void) | null;
+	onDone: (() => void) | null;
+	onError: ((error: Error) => void) | null;
+}
+
+interface BackendRequest {
+	type: "exec" |"eval" | "evaluate" | "stream-start" | "stream-exec" | "stream-stop";
+	id: string;
+	code?: null | string;
+	expr?: null | string;
+}
 
 export class FlaskBackend implements Backend {
-    
-    async init() : Promise<void> {
+	private streamState: StreamState = {
+		id: null,
+		onData: null,
+		onDone: null,
+		onError: null,
+	};
+	private pendingRequests = new Map<string, PendingRequest>();
+	private messageId = 0;
 
-    }
+	// Output callbacks
+	private stdoutCallback: ((value: string) => void) | null = null;
+	private stderrCallback: ((value: string) => void) | null = null;
 
-    terminate(): void {
+	// -------------------------------------------------------------------------
+	// Lifecycle
+	// -------------------------------------------------------------------------
 
-    }
+	async init(): Promise<void> {
+		const state = this.getState();
+		if (state.initialized || state.loading) return;
 
-    getState(): BackendState {
-        return backendState.get()
-    }
+		console.log(
+			"We are ready, this is a flask web server so we don't concern with initialization. Our only concern is whether the server is currently running.",
+		);
+		this.handleResponse({
+			type: "stdout",
+			value: "Your backend preference has been set to a Flask web server, initialization has already occured",
+		});
+
+		console.log("Concluded intialziation state change");
+
+		this.handleResponse({ type: "ready" });
+	}
+
+	terminate(): void {}
+
+	// -------------------------------------------------------------------------
+	// State
+	// -------------------------------------------------------------------------
+
+	getState(): BackendState {
+		return backendState.get();
+	}
+
+	subscribe(callback: (state: BackendState) => void): () => void {
+		return backendState.subscribe(callback);
+	}
+
+	isReady(): boolean {
+		return this.getState().initialized;
+	}
 
-    subscribe(callback: (state: BackendState) => void): () => void {
-        return backendState.subscribe(callback)
+	isLoading(): boolean {
+		return this.getState().loading;
+	}
+
+	getError(): string | null {
+		return this.getState().error;
+	}
+
+	// -------------------------------------------------------------------------
+	// Execution
+	// -------------------------------------------------------------------------
+
+	async exec(
+		code: string,
+		timeout: number = TIMEOUTS.SIMULATION,
+	): Promise<void> {
+
+		const id = this.generateId();
+
+		return new Promise<void>((resolve, reject) => {
+			console.log("Timeout set, the request id is: ", id);
+			console.log(
+				`Do we have request ${id}? ${this.pendingRequests.has(id)}`,
+			);
+			console.log("Pending Requests Map: ", this.pendingRequests);
+			const timeoutId = setTimeout(() => {
+				console.log("Timeout triggered");
+				if (this.pendingRequests.has(id)) {
+					this.pendingRequests.delete(id);
+					reject(new Error("Execution timeout"));
+				}
+			}, timeout);
+
+			this.pendingRequests.set(id, {
+				resolve: () => resolve(),
+				reject,
+				timeoutId,
+			});
+
+			this.handleRequest({ type: "exec", id, code });
+		});
+	}
+
+	async evaluate<T = unknown>(expr: string, timeout?: number): Promise<T> {
+        
+		const id = this.generateId();
+
+        return new Promise<T>((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				if (this.pendingRequests.has(id)) {
+					this.pendingRequests.delete(id);
+					reject(new Error('Evaluation timeout'));
+				}
+			}, timeout);
+
+			this.pendingRequests.set(id, {
+				resolve: (value) => {
+					if (value === undefined) {
+						reject(new Error('No value returned from eval'));
+						return;
+					}
+					try {
+						resolve(JSON.parse(value) as T);
+					} catch {
+						console.log("Error in evaluating the expression:", value)
+						reject(new Error(`Failed to parse eval result: ${value}`));
+					}
+				},
+				reject,
+				timeoutId
+			});
+
+			this.handleRequest({ type: 'eval', id, expr });
+		});
     }
 
+	// -------------------------------------------------------------------------
+	// Streaming
+	// -------------------------------------------------------------------------
+
+	startStreaming<T>(
+		expr: string,
+		onData: (data: T) => void,
+		onDone: () => void,
+		onError: (error: Error) => void,
+	): void {}
+
+	stopStreaming(): void {}
+
+	execDuringStreaming(code: string): void {}
+
+	isStreaming(): boolean {
+		return this.streamState.id != null;
+	}
+
+	// -------------------------------------------------------------------------
+	// Output Callbacks
+	// -------------------------------------------------------------------------
+
+	onStdout(callback: (value: string) => void): void {
+		this.stdoutCallback = callback;
+	}
+
+	onStderr(callback: (value: string) => void): void {
+		this.stderrCallback = callback;
+	}
+
+	// -------------------------------------------------------------------------
+	// Private Functions
+	// -------------------------------------------------------------------------
+	private handleError(response: REPLErrorResponse): void {
+		const { id, error, traceback } = response;
+		const errorMsg = traceback
+			? `${error}\n${traceback}`
+			: error || "Unknown error";
+
+		// Handle pending request errors
+		if (id && this.pendingRequests.has(id)) {
+			const pending = this.pendingRequests.get(id)!;
+			clearTimeout(pending.timeoutId);
+			pending.reject(new Error(errorMsg));
+			this.pendingRequests.delete(id);
+		}
+
+		// Handle streaming errors
+		if (id === this.streamState.id && this.streamState.onError) {
+			this.streamState.onError(new Error(errorMsg));
+			this.streamState = {
+				id: null,
+				onData: null,
+				onDone: null,
+				onError: null,
+			};
+		}
+
+		backendState.update((s) => ({ ...s, error: error || "Unknown error" }));
+	}
+
+	private async runTracebackWithFlask(
+		id: string,
+		error: unknown,
+	): Promise<void> {
+		const errorMsg = error instanceof Error ? error.message : String(error);
+		let traceback: string | undefined;
+
+		try {
+			traceback = (
+				await fetch(getFlaskBackendUrl() + "/traceback")
+					.then((res) => res.json())
+					.then((res) => res.json)
+			).traceback as string;
+		} catch (error) {
+			// Ignore as in the Pyodide framework
+		}
+
+		this.handleResponse({ type: "error", id, error: errorMsg, traceback });
+	}
+
+	private handleResponse(response: REPLResponse): void {
+		switch (response.type) {
+			case "ready":
+				backendState.update((s) => ({
+					...s,
+					initialized: true,
+					loading: false,
+					progress: STATUS_MESSAGES.READY,
+				}));
+				break;
+
+			case "progress":
+				backendState.update((s) => ({
+					...s,
+					progress: response.value || "",
+				}));
+				break;
+
+			case "ok":
+				if (response.id && this.pendingRequests.has(response.id)) {
+					const pending = this.pendingRequests.get(response.id)!;
+					clearTimeout(pending.timeoutId);
+					pending.resolve(undefined);
+					this.pendingRequests.delete(response.id);
+				}
+				break;
+
+			case "value":
+				if (response.id && this.pendingRequests.has(response.id)) {
+					const pending = this.pendingRequests.get(response.id)!;
+					clearTimeout(pending.timeoutId);
+					pending.resolve(response.value);
+					this.pendingRequests.delete(response.id);
+				}
+				break;
+
+			case "error":
+				this.handleError(response);
+				break;
+
+			case "stdout":
+				if (response.value && this.stdoutCallback) {
+					this.stdoutCallback(response.value);
+				}
+				break;
+
+			case "stderr":
+				if (response.value && this.stderrCallback) {
+					this.stderrCallback(response.value);
+				}
+				break;
+
+			case "stream-data":
+				if (
+					response.id === this.streamState.id &&
+					this.streamState.onData &&
+					response.value
+				) {
+					try {
+						this.streamState.onData(JSON.parse(response.value));
+					} catch {
+						// Ignore parse errors
+					}
+				}
+				break;
+
+			case "stream-done":
+				if (
+					response.id === this.streamState.id &&
+					this.streamState.onDone
+				) {
+					this.streamState.onDone();
+					this.streamState = {
+						id: null,
+						onData: null,
+						onDone: null,
+						onError: null,
+					};
+				}
+				break;
+		}
+	}
+
+	private generateId(): string {
+		return `repl_${++this.messageId}`;
+	}
+
+	private async handleRequest(request: BackendRequest) {
+		let { type, id, code, expr } = request;
+		switch (type) {
+			case "exec":
+				try {
+					let data = await fetch(
+						getFlaskBackendUrl() + "/execute-code",
+						{
+							method: "POST",
+							headers: {
+								"Content-Type": "application/json",
+							},
+							body: JSON.stringify({ code: code }),
+						},
+					).then((res) => res.json());
+					if (data.success && !data.error) {
+						if (data.output) {
+							this.handleResponse({
+								type: "stdout",
+								value: data.output,
+							});
+						}
+						this.handleResponse({ type: "ok", id });
+					} else {
+						throw Error(data.error);
+					}
+				} catch (error) {
+					// This traceback may actually be unnecessary in all Flaskc ases,
+					// unless there is someway that the error output doesn't fully capture all the relevant information
+					return this.runTracebackWithFlask(id, error);
+				}
+				break;
+
+			case "eval":
+				try {
+					let data = await fetch(
+						getFlaskBackendUrl() + "/evaluate-expression",
+						{
+							method: "POST",
+							headers: {
+								"Content-Type": "application/json",
+							},
+							body: JSON.stringify({ expr: expr }),
+						},
+					).then((res) => res.json());
+					if (data.success && !data.error) {
+						if (data.output) {
+							this.handleResponse({
+								type: "stdout",
+								value: data.output,
+							});
+						}
+						console.log(
+							"\n\n(Flask) The evaluated result from evaluating the expression: ",
+							JSON.stringify(data.result),
+							"\n\n",
+						);
+						this.handleResponse({
+							type: "value",
+							id,
+							value: JSON.stringify(data.result) as string,
+						});
+					} else {
+						throw Error(data.error);
+					}
+				} catch (error) {
+					return this.runTracebackWithFlask(id, error);
+				}
+				break;
+
+			case "stream-start":
+				break;
+
+			case "stream-exec":
+				break;
 
-}
\ No newline at end of file
+			case "stream-stop":
+				break;
+		}
+	}
+}
diff --git a/src/lib/pyodide/backend/registry.ts b/src/lib/pyodide/backend/registry.ts
index 2b5346df..68ecf5da 100644
--- a/src/lib/pyodide/backend/registry.ts
+++ b/src/lib/pyodide/backend/registry.ts
@@ -7,6 +7,7 @@ import type { Backend } from './types';
 import { PyodideBackend } from './pyodide/backend';
 import type { BackendPreference } from '$lib/types';
 import { backendPreferenceStore } from '$lib/stores';
+import { FlaskBackend } from './flask/backend';
 
 export type BackendType = 'pyodide' | 'local' | 'remote';
 
@@ -38,9 +39,9 @@ export function createBackend(type: null |  BackendPreference): Backend {
 		case null:
 			return new PyodideBackend();
 		case 'flask':
-			let backend = new PyodideBackend()
-			backend.setBackendPreference("flask")
-			return backend
+			// let backend = new PyodideBackend()
+			// backend.setBackendPreference("flask")
+			return new FlaskBackend()
 		// case 'remote':
 		// 	throw new Error(`Backend type '${type}' not yet implemented`);
 		default:
diff --git a/src/lib/pyodide/bridge.ts b/src/lib/pyodide/bridge.ts
index 56304351..e0658635 100644
--- a/src/lib/pyodide/bridge.ts
+++ b/src/lib/pyodide/bridge.ts
@@ -529,7 +529,6 @@ export async function validateGraph(
 
 		// Get validation result
 		const result = await evaluate<ValidationResult>(VALIDATION_RESULT_EXPR, TIMEOUTS.VALIDATION);
-
 		// Clean up
 		await exec(CLEANUP_TEMP_CODE);
 

From e8505db4acf60bde911e9a61c8e92564cfcbd7c8 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 12:28:01 -0500
Subject: [PATCH 25/39] Successfully transfered all the worker.ts Flask
 alternative code into a separate Flask Backend class, now I just need to
 begin working on Flask streaming and removing the Flask code from worker.ts

---
 src/lib/pyodide/backend/flask/backend.ts | 185 ++++++++++++++++++++---
 1 file changed, 168 insertions(+), 17 deletions(-)

diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 70483239..6d50bd7b 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -32,13 +32,22 @@ interface StreamState {
 }
 
 interface BackendRequest {
-	type: "exec" |"eval" | "evaluate" | "stream-start" | "stream-exec" | "stream-stop";
-	id: string;
+	type:
+		| "exec"
+		| "eval"
+		| "evaluate"
+		| "stream-start"
+		| "stream-exec"
+		| "stream-stop";
+	id?: string;
 	code?: null | string;
 	expr?: null | string;
 }
 
 export class FlaskBackend implements Backend {
+	streamingCodeQueue: string[] = [];
+    streamingActive : boolean = false
+
 	private streamState: StreamState = {
 		id: null,
 		onData: null,
@@ -107,7 +116,6 @@ export class FlaskBackend implements Backend {
 		code: string,
 		timeout: number = TIMEOUTS.SIMULATION,
 	): Promise<void> {
-
 		const id = this.generateId();
 
 		return new Promise<void>((resolve, reject) => {
@@ -134,38 +142,45 @@ export class FlaskBackend implements Backend {
 		});
 	}
 
-	async evaluate<T = unknown>(expr: string, timeout?: number): Promise<T> {
-        
+	async evaluate<T = unknown>(
+		expr: string,
+		timeout: number = TIMEOUTS.SIMULATION,
+	): Promise<T> {
 		const id = this.generateId();
 
-        return new Promise<T>((resolve, reject) => {
+		return new Promise<T>((resolve, reject) => {
 			const timeoutId = setTimeout(() => {
 				if (this.pendingRequests.has(id)) {
 					this.pendingRequests.delete(id);
-					reject(new Error('Evaluation timeout'));
+					reject(new Error("Evaluation timeout"));
 				}
 			}, timeout);
 
 			this.pendingRequests.set(id, {
 				resolve: (value) => {
 					if (value === undefined) {
-						reject(new Error('No value returned from eval'));
+						reject(new Error("No value returned from eval"));
 						return;
 					}
 					try {
 						resolve(JSON.parse(value) as T);
 					} catch {
-						console.log("Error in evaluating the expression:", value)
-						reject(new Error(`Failed to parse eval result: ${value}`));
+						console.log(
+							"Error in evaluating the expression:",
+							value,
+						);
+						reject(
+							new Error(`Failed to parse eval result: ${value}`),
+						);
 					}
 				},
 				reject,
-				timeoutId
+				timeoutId,
 			});
 
-			this.handleRequest({ type: 'eval', id, expr });
+			this.handleRequest({ type: "eval", id, expr });
 		});
-    }
+	}
 
 	// -------------------------------------------------------------------------
 	// Streaming
@@ -176,16 +191,138 @@ export class FlaskBackend implements Backend {
 		onData: (data: T) => void,
 		onDone: () => void,
 		onError: (error: Error) => void,
-	): void {}
+	): void {
+		if (!this.isReady()) {
+			onError(new Error("Backend not initialized"));
+			return;
+		}
 
-	stopStreaming(): void {}
+		// Stop any existing stream
+		if (this.streamState.id) {
+			this.stopStreaming();
+		}
 
-	execDuringStreaming(code: string): void {}
+		const id = this.generateId();
+		this.streamState = {
+			id,
+			onData: onData as (data: unknown) => void,
+			onDone,
+			onError,
+		};
+
+		this.handleRequest({ type: "stream-start", id, expr });
+	}
+
+	stopStreaming(): void {
+		if (!this.streamState.id) return;
+
+		this.handleRequest({ type: "stream-stop" });
+	}
+
+	execDuringStreaming(code: string): void {
+		if (!this.streamState.id) {
+			console.warn("Cannot exec during streaming: no active stream");
+			return;
+		}
+		this.handleRequest({ type: "stream-exec", code });
+	}
 
 	isStreaming(): boolean {
 		return this.streamState.id != null;
 	}
 
+    private async runStreamingLoop(id: string, expr: string):Promise<void> {
+
+        try {
+            this.streamingActive = true;
+        
+            this.streamingCodeQueue.length = 0;
+            while (this.streamingActive) {
+              // Execute any queued code first (for runtime parameter changes, events, etc.)
+              // Errors in queued code are reported but don't stop the simulation
+              while (this.streamingCodeQueue.length > 0) {
+                const code = this.streamingCodeQueue.shift()!;
+                try {
+                  // Simply sending requests to the Flask api to execute code, we only really care if errors are produced so we
+                  // don't handle any data response
+        
+                  let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
+                    method: "POST",
+                    headers: {
+                      "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ code: code }),
+                  }).then(res => res.json());
+                  if(data.success && data.output) {
+                    this.handleResponse({ type: "stdout", value: data.output })
+                  } else {
+                    throw Error(data.error)
+                  }
+                } catch (error) {
+                  const errorMsg =
+                    error instanceof Error ? error.message : String(error);
+                  this.handleResponse({ type: "stderr", value: `Stream exec error: ${errorMsg}` });
+                }
+              }
+        
+              let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ expr: expr }),
+              }).then((res) => res.json());
+        
+              if (data.success && !data.error) {
+                if(data.output) {
+                  this.handleResponse({ type: "stdout", value: data.output })
+                }
+                data = data.result;
+              } else {
+                throw Error(data.error);
+              }
+        
+              // console.log("Resultant returned is: ", data)
+        
+              if (!this.streamingActive) {
+                if (!data.done && data.result) {
+                  // console.log("Still streaming data....")
+                  if(data.result) {
+                    console.log("(Flask) Still streaming data, but this value was returned: ", data.result)
+                  }
+                  this.handleResponse({
+                    type: "stream-data",
+                    id,
+                    value: JSON.stringify(data.result) as string,
+                  });
+                }
+                break;
+              }
+        
+              if (data.done) {
+                break;
+              }
+        
+              console.log(
+                "(Flask) Done streaming data, the final value is....",
+                data,
+              );
+        
+              this.handleResponse({
+                type: "stream-data",
+                id,
+                value: JSON.stringify(data) as string,
+              });
+            }
+          } catch (error) {
+            return this.runTracebackWithFlask(id, error);
+          } finally {
+            this.streamingActive = false;
+            console.log("Have completely finished streaming!");
+            this.handleResponse({ type: "stream-done", id });
+          }
+    }
+
 	// -------------------------------------------------------------------------
 	// Output Callbacks
 	// -------------------------------------------------------------------------
@@ -333,11 +470,13 @@ export class FlaskBackend implements Backend {
 	}
 
 	private generateId(): string {
-		return `repl_${++this.messageId}`;
+		return `flask_repl_${++this.messageId}`;
 	}
 
 	private async handleRequest(request: BackendRequest) {
 		let { type, id, code, expr } = request;
+        id = "id" in request ? request.id as string : "";
+
 		switch (type) {
 			case "exec":
 				try {
@@ -407,13 +546,25 @@ export class FlaskBackend implements Backend {
 				break;
 
 			case "stream-start":
+                if (!id || typeof expr !== "string") {
+                throw new Error("Invalid stream-start request: missing id or expr");
+                }
+                // Don't await - let it run autonomously
+                this.runStreamingLoop(id, expr);
 				break;
 
 			case "stream-exec":
+				if (typeof code === "string" && this.isStreaming()) {
+					// Queue code to be executed between generator steps
+					this.streamingCodeQueue.push(code);
+				}
 				break;
 
 			case "stream-stop":
+                this.streamingActive = false
 				break;
+            default:
+                throw new Error(`Unknown message type: ${type}`);
 		}
 	}
 }

From 3335c727867c9df4d9515438c0b79178e82fd378 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 14:07:38 -0500
Subject: [PATCH 26/39] Removed a bunch of the unnecessary, zombie code

---
 src/backend.py                            |  56 ------
 src/lib/pyodide/backend/flask/backend.ts  |  12 +-
 src/lib/pyodide/backend/pyodide/worker.ts | 205 +---------------------
 src/lib/pyodide/bridge.ts                 |   1 +
 4 files changed, 11 insertions(+), 263 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 170f95bf..8bb6eda1 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -148,62 +148,6 @@ def check_traceback():
 @app.route("/streamData", methods=["POST"])
 def stream_data():
     pass
-# @app.route("/runGraphStreamingSimulation", methods=["POST"])
-# def runGraphStreamingSimulation():
-#     try:
-#         # Not fully implemented yet
-#         data = request.get_json()
-#         nodes, connections, settings_store, code_context, events = data["nodes"], data["connections"], data["settingsStore"], data["codeContext"], data["events"]
-
-#         pass
-#     except KeyError as e:
-#         return jsonify({"success": False, "error": f"Missing key, error: {e}"})
-#     except Exception as e:
-#         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-
-# @app.route("/validateGraphSimulation", methods=["POST"])
-# def validateGraphSimulation():
-#     print("Received a request at /validateGraphSimulation")
-
-#     try:
-#         # Not fully implemented yet
-#         # - We are going to have to recreate nodeRegistry functionality when given the 
-#         # - The original validation program has extractParams() and validateGraphBridge() run
-#         # - extractParams() uses primarily nodeRegistry functionality
-#         # - validateGraphBridge() uses a bunch of generated Python code to run in Pyodide s.t. we can just run it here
-
-#         data = request.get_json()
-#         nodes, code_context, node_registry_nodes = data.get("nodes"), data.get("codeContext"), data.get("nodeRegistryNodes")
-#         print("Node registry is: ", node_registry_nodes)
-
-#         # Extract Node Params
-
-
-#         # Validate Graph Bridge
-
-
-#         return jsonify({"success": True, "data": {
-#             "valid": False,
-#             "errors": []
-#         }})
-#         pass
-#     except KeyError as e:
-#         return jsonify({"success": False, "error": f"Missing key, error: {e}"})
-#     except Exception as e:
-#         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
-
-
-# # ------------------- STATE DEPENDENT / CHANGING ROUTES ------------------
-
-# @app.route("/continueStreamingSimulation", methods=["POST"])
-# def continueStreamingSimulation():
-#     try:
-#         # Not fully implemented yet
-
-#         data = request.get_json()
-#         duration = data["duration"]
-#     except Exception as e:
-#         return jsonify({"success": False, "error": f"Server-side error: {e}"}), 500
 
 # Global error handler to ensure all errors return JSON
 @app.errorhandler(Exception)
diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 6d50bd7b..fa4cdfd5 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -119,11 +119,6 @@ export class FlaskBackend implements Backend {
 		const id = this.generateId();
 
 		return new Promise<void>((resolve, reject) => {
-			console.log("Timeout set, the request id is: ", id);
-			console.log(
-				`Do we have request ${id}? ${this.pendingRequests.has(id)}`,
-			);
-			console.log("Pending Requests Map: ", this.pendingRequests);
 			const timeoutId = setTimeout(() => {
 				console.log("Timeout triggered");
 				if (this.pendingRequests.has(id)) {
@@ -237,6 +232,13 @@ export class FlaskBackend implements Backend {
             this.streamingActive = true;
         
             this.streamingCodeQueue.length = 0;
+
+            if(this.streamingCodeQueue.length == 0) {
+            console.log("Streaming code queue is empty...")
+            } else {
+            console.log("There is something in the streaming code queue...", this.streamingCodeQueue)
+            }
+
             while (this.streamingActive) {
               // Execute any queued code first (for runtime parameter changes, events, etc.)
               // Errors in queued code are reported but don't stop the simulation
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 4b02558b..4eb9a454 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -13,13 +13,9 @@ import { PROGRESS_MESSAGES, ERROR_MESSAGES } from '$lib/constants/messages';
 import type { REPLRequest, REPLResponse } from '../types';
 
 import type { PyodideInterface } from "https://cdn.jsdelivr.net/pyodide/v0.26.2/full/pyodide.mjs";
-import { getFlaskBackendUrl } from "$lib/utils/flaskRoutes";
-import { backendPreferenceStore, consoleStore } from "$lib/stores";
-import type { BackendPreference } from "$lib/types";
 
 let pyodide: PyodideInterface | null = null;
 let isInitialized = false;
-let backendPreference: null | BackendPreference = null;
 let streamingActive = false;
 const streamingCodeQueue: string[] = [];
 
@@ -33,12 +29,7 @@ function send(response: REPLResponse): void {
 /**
  * Initialize Pyodide and install packages (Needs FLASK Rework)
  */
-async function initialize(eventPreference: BackendPreference): Promise<void> {
-  console.log(
-    `(worker.ts, initialize) Setting the backend preference to: ${eventPreference}`,
-  );
-  backendPreference = eventPreference as BackendPreference;
-  if (!backendPreference || backendPreference == "pyodide") {
+async function initialize(): Promise<void> {
     // Default to pyodide use
     if (isInitialized) {
       send({ type: "ready" });
@@ -103,31 +94,12 @@ print(f"${pkg.import} {${pkg.import}.__version__} loaded successfully")
 
     isInitialized = true;
     send({ type: "ready" });
-  } else {
-    /*	By default the isFlaskInitialized variable is true as we have the backend constantly running on a hosted server
-     */
-    if (isInitialized) {
-      send({ type: "ready" });
-      return;
-    }
-
-    console.log(
-      "We are ready, this is a flask web server so we don't concern with initialization. Our only concern is whether the server is currently running.",
-    );
-
-    isInitialized = true;
-    send({ type: "stdout", value: "Your backend preference has been set to a Flask web server, initialization has already occured"})
-    console.log("Concluded intialziation state change");
-    send({ type: "ready" });
-  }
 }
 
 /**
  * Execute Python code (no return value) (Needs FLASK Rework)
  */
 async function execCode(id: string, code: string): Promise<void> {
-  console.log("(execCode) This backends preference is " + backendPreference);
-  if (!backendPreference || backendPreference == "pyodide") {
     // Default to pyodide use
     if (!pyodide) {
       console.log(`Within execCode() I have an uninitialized worker!`); // Debugging console
@@ -150,33 +122,7 @@ traceback.format_exc()
       }
       send({ type: "error", id, error: errorMsg, traceback });
     }
-  } else {
-    return execCodeWithFlask(id, code);
-  }
-}
-
-async function execCodeWithFlask(id: string, code: string): Promise<void> {
-  try {
-    let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ code: code }),
-    }).then((res) => res.json());
-    if (data.success && !data.error) {
-      if(data.output) {
-        send({type: "stdout", value: data.output })
-      }
-      send({ type: "ok", id });
-    } else {
-      throw Error(data.error);
-    }
-  } catch (error) { 
-    // This traceback may actually be unnecessary in all Flaskc ases,
-    // unless there is someway that the error output doesn't fully capture all the relevant information
-    return runTracebackWithFlask(id, error);
-  }
+  
 }
 
 /**
@@ -184,7 +130,6 @@ async function execCodeWithFlask(id: string, code: string): Promise<void> {
  * Note: _to_json helper is injected via REPL_SETUP_CODE (Needs FLASK Rework)
  */
 async function evalExpr(id: string, expr: string): Promise<void> {
-  if (!backendPreference || backendPreference == "pyodide") {
     // Default to pyodide use
     if (!pyodide) {
       console.log(`Within evalExpr() I have an uninitialized worker!`); // Debugging console
@@ -215,44 +160,14 @@ traceback.format_exc()
       }
       send({ type: "error", id, error: errorMsg, traceback });
     }
-  } else {
-    return evalExprWithFlask(id, expr);
-  }
 }
 
-async function evalExprWithFlask(id: string, expr: string): Promise<void> {
-  try {
-    let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ expr: expr }),
-    }).then((res) => res.json());
-    if (data.success && !data.error) {
-      if(data.output) {
-        send({type: "stdout", value: data.output })
-      }
-      console.log(
-        "\n\n(Flask) The evaluated result from evaluating the expression: ",
-        JSON.stringify(data.result),
-        "\n\n",
-      );
-      send({ type: "value", id, value: JSON.stringify(data.result) as string });
-    } else {
-      throw Error(data.error);
-    }
-  } catch (error) {
-    return runTracebackWithFlask(id, error);
-  }
-}
 
 /**
  * Run streaming loop - steps generator continuously and posts results
  * Runs autonomously until done or stopped (Needs FLASK Rework)
  */
 async function runStreamingLoop(id: string, expr: string): Promise<void> {
-  if (backendPreference == "pyodide" || !backendPreference) {
     if (!pyodide) {
       console.log(`Within runStreamingLoop() I have an uninitialized worker!`); // Debugging console
       throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
@@ -326,115 +241,6 @@ traceback.format_exc()
       // Always send done when loop ends (whether completed, stopped, or error)
       send({ type: "stream-done", id });
     }
-  } else {
-    return runStreamingLoopWithFlask(id, expr);
-  }
-}
-
-async function runStreamingLoopWithFlask(id: string, expr: string) {
-  try {
-    streamingActive = true;
-
-    streamingCodeQueue.length = 0;
-    while (streamingActive) {
-      // Execute any queued code first (for runtime parameter changes, events, etc.)
-      // Errors in queued code are reported but don't stop the simulation
-      while (streamingCodeQueue.length > 0) {
-        const code = streamingCodeQueue.shift()!;
-        try {
-          // Simply sending requests to the Flask api to execute code, we only really care if errors are produced so we
-          // don't handle any data response
-
-          let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ code: code }),
-          }).then(res => res.json());
-          if(data.success && data.output) {
-            send({ type: "stdout", value: data.output })
-          } else {
-            throw Error(data.error)
-          }
-        } catch (error) {
-          const errorMsg =
-            error instanceof Error ? error.message : String(error);
-          send({ type: "stderr", value: `Stream exec error: ${errorMsg}` });
-        }
-      }
-
-      let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ expr: expr }),
-      }).then((res) => res.json());
-
-      if (data.success && !data.error) {
-        if(data.output) {
-          send({ type: "stdout", value: data.output })
-        }
-        data = data.result;
-      } else {
-        throw Error(data.error);
-      }
-
-      // console.log("Resultant returned is: ", data)
-
-      if (!streamingActive) {
-        if (!data.done && data.result) {
-          // console.log("Still streaming data....")
-          if(data.result) {
-            console.log("(Flask) Still streaming data, but this value was returned: ", data.result)
-          }
-          send({
-            type: "stream-data",
-            id,
-            value: JSON.stringify(data.result) as string,
-          });
-        }
-        break;
-      }
-
-      if (data.done) {
-        break;
-      }
-
-      console.log(
-        "(Flask) Done streaming data, the final value is....",
-        data,
-      );
-
-      send({
-        type: "stream-data",
-        id,
-        value: JSON.stringify(data) as string,
-      });
-    }
-  } catch (error) {
-    return runTracebackWithFlask(id, error);
-  } finally {
-    streamingActive = false;
-    console.log("Have completely finished streaming!");
-    send({ type: "stream-done", id });
-  }
-}
-
-async function runTracebackWithFlask(id: string, error: unknown) {
-  const errorMsg = error instanceof Error ? error.message : String(error);
-  let traceback: string | undefined;
-  try {
-    traceback = (
-      await fetch(getFlaskBackendUrl() + "/traceback")
-        .then((res) => res.json())
-        .then((res) => res.json)
-    ).traceback as string;
-  } catch (error) {
-    // Ignore as in the Pyodide framework
-  }
-  send({ type: "error", id, error: errorMsg, traceback });
 }
 
 /**
@@ -452,16 +258,11 @@ self.onmessage = async (event: MessageEvent<REPLRequest>) => {
   const code = "code" in event.data ? event.data.code : undefined;
   const expr = "expr" in event.data ? event.data.expr : undefined;
 
-  const preference =
-    "backendPreference" in event.data
-      ? event.data.backendPreference
-      : "pyodide";
 
   try {
     switch (type) {
       case "init":
-        console.log("Event Data is: ", event.data);
-        await initialize(preference as BackendPreference);
+        await initialize();
         break;
 
       case "exec":
diff --git a/src/lib/pyodide/bridge.ts b/src/lib/pyodide/bridge.ts
index e0658635..678e68d6 100644
--- a/src/lib/pyodide/bridge.ts
+++ b/src/lib/pyodide/bridge.ts
@@ -580,6 +580,7 @@ export async function stopSimulation(): Promise<void> {
 if 'sim' in dir() and sim is not None:
     sim.stop()
 		`, TIMEOUTS.VALIDATION);
+		consoleStore.info("Stopped simulation (streaming)...")
 	} catch {
 		// Ignore errors - simulation might not exist yet
 	}

From d3c3757a4745b1ec2e4ce6de3e44f82961ce388b Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 14:30:21 -0500
Subject: [PATCH 27/39] Developing new /streamData api route, which will handle
 all the looping logic within a single api request and then stream the
 resulting data!

---
 src/backend.py                           | 40 +++++++++++++++++++++++-
 src/lib/pyodide/backend/flask/backend.ts |  9 ++++--
 2 files changed, 45 insertions(+), 4 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 8bb6eda1..c745a014 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -147,7 +147,45 @@ def check_traceback():
 
 @app.route("/streamData", methods=["POST"])
 def stream_data():
-    pass
+    try:
+        data = request.json
+        expr = data.get("expr")
+
+        # Capture stdout and stderror
+        stdout_capture = io.StringIO()
+        stderr_capture = io.StringIO()
+
+        try:
+            result = " "
+            with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                result = eval(expr, namespace)
+            
+            print("The result was: ", result)
+
+            # Capture any output
+            output = stdout_capture.getvalue()
+            error_output = stderr_capture.getvalue()
+
+            if error_output:
+                return jsonify({"success": False, "error": error_output})
+            
+            return jsonify(
+                {
+                    "success": True,
+                    "result": result,
+                    "output": output
+                }
+            )
+        
+        except SyntaxError as e:
+            return jsonify({"success": False, "error": f"Syntax Error: {str(e)}"}), 400
+        except Exception as e:
+            return jsonify({"success": False, "error": f"Runtime Error: {str(e)}"}), 400   
+
+
+    except Exception as e:
+        return jsonify({"success": False, "error": f"Server error: {str(e)}"}), 500
+
 
 # Global error handler to ensure all errors return JSON
 @app.errorhandler(Exception)
diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index fa4cdfd5..8e2a6f8e 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -245,8 +245,9 @@ export class FlaskBackend implements Backend {
               while (this.streamingCodeQueue.length > 0) {
                 const code = this.streamingCodeQueue.shift()!;
                 try {
-                  // Simply sending requests to the Flask api to execute code, we only really care if errors are produced so we
-                  // don't handle any data response
+                  // Simply sending requests to the Flask api to execute code, 
+                  // we only really care if errors are produced so we don't handle any data response.
+                  // There is also no need for streaming data here....
         
                   let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
                     method: "POST",
@@ -266,8 +267,10 @@ export class FlaskBackend implements Backend {
                   this.handleResponse({ type: "stderr", value: `Stream exec error: ${errorMsg}` });
                 }
               }
+
+              console.log("Streaming code expression is: ", expr)
         
-              let data = await fetch(getFlaskBackendUrl() + "/evaluate-expression", {
+              let data = await fetch(getFlaskBackendUrl() + "/streamData", {
                 method: "POST",
                 headers: {
                   "Content-Type": "application/json",

From 729acff98444121698a0b761cffb8701df612497 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 15:28:02 -0500
Subject: [PATCH 28/39] Beginning to refine the /streamData endpoint, the
 generator function is working out but I need to work on fetching those
 results

---
 src/backend.py                           | 40 ++++++++++++++++++------
 src/lib/pyodide/backend/flask/backend.ts |  1 +
 2 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index c745a014..e2a92569 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -2,7 +2,7 @@
 import json
 import traceback
 import requests as req
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, Response, stream_with_context
 from flask_cors import CORS
 
 import io
@@ -15,7 +15,9 @@
 import pathsim, pathsim_chem
 
 print(f"PathSim {pathsim.__version__} loaded successfully")
-    
+
+STREAMING_STEP_EXPR = "_step_streaming_gen()"
+
 _clean_globals = set(globals().keys())
 namespace = {}
 
@@ -147,35 +149,53 @@ def check_traceback():
 
 @app.route("/streamData", methods=["POST"])
 def stream_data():
-    try:
-        data = request.json
-        expr = data.get("expr")
-
+    def generate(expr):
         # Capture stdout and stderror
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
 
-        try:
+        isDone = False
+        count = 0
+        
+        while not isDone:
+            print("(Generator) Count: ", count)
+            # print("Generator expression is: ", expr)
+            # yield json.dumps({"name": "Ayo", "age": 18})
+
             result = " "
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
                 result = eval(expr, namespace)
-            
-            print("The result was: ", result)
+        
+            print("Is the result done? ", result["done"])
 
             # Capture any output
             output = stdout_capture.getvalue()
             error_output = stderr_capture.getvalue()
 
             if error_output:
+                print("Oh no there was an error ;-;")
                 return jsonify({"success": False, "error": error_output})
             
-            return jsonify(
+            yield json.dumps(
                 {
                     "success": True,
                     "result": result,
                     "output": output
                 }
             )
+
+            count += 1
+
+            if result["done"]:
+                print("Concluding the while loop!")
+                isDone = True
+    
+    try:
+        data = request.json
+        expr = data.get("expr")
+
+        try:
+            return Response(stream_with_context(generate(expr)))
         
         except SyntaxError as e:
             return jsonify({"success": False, "error": f"Syntax Error: {str(e)}"}), 400
diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 8e2a6f8e..671a4028 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -279,6 +279,7 @@ export class FlaskBackend implements Backend {
               }).then((res) => res.json());
         
               if (data.success && !data.error) {
+                console.log("Data: ", data)
                 if(data.output) {
                   this.handleResponse({ type: "stdout", value: data.output })
                 }

From 15e54d5f9ef6633a572ef26d7cccce7363fdbf16 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 16:03:53 -0500
Subject: [PATCH 29/39] Successfully decoding chunks from a readable stream
 that comes from a single API request!

---
 src/backend.py                           |  17 +-
 src/lib/pyodide/backend/flask/backend.ts | 280 ++++++++++++++---------
 2 files changed, 181 insertions(+), 116 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index e2a92569..7ff903ba 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -147,7 +147,7 @@ def check_traceback():
     except Exception as e:
         return jsonify({"success": False, "error": f"Server-side error: {e}"})
 
-@app.route("/streamData", methods=["POST"])
+@app.route("/streamData", methods=["POST", "GET"])
 def stream_data():
     def generate(expr):
         # Capture stdout and stderror
@@ -176,6 +176,10 @@ def generate(expr):
                 print("Oh no there was an error ;-;")
                 return jsonify({"success": False, "error": error_output})
             
+            # Directly responding with a Flask Response object (as jsonify(...) does) doesn't work
+            # so we need to use the json.dumps(...) function to return a string so that it can pass into
+            # stream_with_context(...)
+
             yield json.dumps(
                 {
                     "success": True,
@@ -191,11 +195,16 @@ def generate(expr):
                 isDone = True
     
     try:
-        data = request.json
-        expr = data.get("expr")
+        method = request.method
+        
+        expr = STREAMING_STEP_EXPR
+
+        if method == "POST":
+            data = request.json
+            expr = data.get("expr")
 
         try:
-            return Response(stream_with_context(generate(expr)))
+            return Response(stream_with_context(generate(expr)), content_type='application/json')
         
         except SyntaxError as e:
             return jsonify({"success": False, "error": f"Syntax Error: {str(e)}"}), 400
diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 671a4028..8bf5f481 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -46,7 +46,7 @@ interface BackendRequest {
 
 export class FlaskBackend implements Backend {
 	streamingCodeQueue: string[] = [];
-    streamingActive : boolean = false
+	streamingActive: boolean = false;
 
 	private streamState: StreamState = {
 		id: null,
@@ -226,108 +226,162 @@ export class FlaskBackend implements Backend {
 		return this.streamState.id != null;
 	}
 
-    private async runStreamingLoop(id: string, expr: string):Promise<void> {
-
-        try {
-            this.streamingActive = true;
-        
-            this.streamingCodeQueue.length = 0;
-
-            if(this.streamingCodeQueue.length == 0) {
-            console.log("Streaming code queue is empty...")
-            } else {
-            console.log("There is something in the streaming code queue...", this.streamingCodeQueue)
-            }
-
-            while (this.streamingActive) {
-              // Execute any queued code first (for runtime parameter changes, events, etc.)
-              // Errors in queued code are reported but don't stop the simulation
-              while (this.streamingCodeQueue.length > 0) {
-                const code = this.streamingCodeQueue.shift()!;
-                try {
-                  // Simply sending requests to the Flask api to execute code, 
-                  // we only really care if errors are produced so we don't handle any data response.
-                  // There is also no need for streaming data here....
-        
-                  let data = await fetch(getFlaskBackendUrl() + "/execute-code", {
-                    method: "POST",
-                    headers: {
-                      "Content-Type": "application/json",
-                    },
-                    body: JSON.stringify({ code: code }),
-                  }).then(res => res.json());
-                  if(data.success && data.output) {
-                    this.handleResponse({ type: "stdout", value: data.output })
-                  } else {
-                    throw Error(data.error)
-                  }
-                } catch (error) {
-                  const errorMsg =
-                    error instanceof Error ? error.message : String(error);
-                  this.handleResponse({ type: "stderr", value: `Stream exec error: ${errorMsg}` });
-                }
-              }
-
-              console.log("Streaming code expression is: ", expr)
-        
-              let data = await fetch(getFlaskBackendUrl() + "/streamData", {
-                method: "POST",
-                headers: {
-                  "Content-Type": "application/json",
-                },
-                body: JSON.stringify({ expr: expr }),
-              }).then((res) => res.json());
-        
-              if (data.success && !data.error) {
-                console.log("Data: ", data)
-                if(data.output) {
-                  this.handleResponse({ type: "stdout", value: data.output })
-                }
-                data = data.result;
-              } else {
-                throw Error(data.error);
-              }
-        
-              // console.log("Resultant returned is: ", data)
-        
-              if (!this.streamingActive) {
-                if (!data.done && data.result) {
-                  // console.log("Still streaming data....")
-                  if(data.result) {
-                    console.log("(Flask) Still streaming data, but this value was returned: ", data.result)
-                  }
-                  this.handleResponse({
-                    type: "stream-data",
-                    id,
-                    value: JSON.stringify(data.result) as string,
-                  });
-                }
-                break;
-              }
-        
-              if (data.done) {
-                break;
-              }
-        
-              console.log(
-                "(Flask) Done streaming data, the final value is....",
-                data,
-              );
-        
-              this.handleResponse({
-                type: "stream-data",
-                id,
-                value: JSON.stringify(data) as string,
-              });
-            }
-          } catch (error) {
-            return this.runTracebackWithFlask(id, error);
-          } finally {
-            this.streamingActive = false;
-            console.log("Have completely finished streaming!");
-            this.handleResponse({ type: "stream-done", id });
-          }
-    }
+	private async runStreamingLoop(id: string, expr: string): Promise<void> {
+		try {
+			this.streamingActive = true;
+
+			this.streamingCodeQueue.length = 0;
+
+			if (this.streamingCodeQueue.length == 0) {
+				console.log("Streaming code queue is empty...");
+			} else {
+				console.log(
+					"There is something in the streaming code queue...",
+					this.streamingCodeQueue,
+				);
+			}
+
+			while (this.streamingActive) {
+				// Execute any queued code first (for runtime parameter changes, events, etc.)
+				// Errors in queued code are reported but don't stop the simulation
+				while (this.streamingCodeQueue.length > 0) {
+					const code = this.streamingCodeQueue.shift()!;
+					try {
+						// Simply sending requests to the Flask api to execute code,
+						// we only really care if errors are produced so we don't handle any data response.
+						// There is also no need for streaming data here....
+
+						let data = await fetch(
+							getFlaskBackendUrl() + "/execute-code",
+							{
+								method: "POST",
+								headers: {
+									"Content-Type": "application/json",
+								},
+								body: JSON.stringify({ code: code }),
+							},
+						).then((res) => res.json());
+						if (data.success && data.output) {
+							this.handleResponse({
+								type: "stdout",
+								value: data.output,
+							});
+						} else {
+							throw Error(data.error);
+						}
+					} catch (error) {
+						const errorMsg =
+							error instanceof Error
+								? error.message
+								: String(error);
+						this.handleResponse({
+							type: "stderr",
+							value: `Stream exec error: ${errorMsg}`,
+						});
+					}
+				}
+
+				console.log("Streaming code expression is: ", expr);
+
+				let data = await fetch(
+					getFlaskBackendUrl() + "/streamData",
+				).then((res) => {
+					const reader = res.body?.getReader();
+					return new ReadableStream({
+						start(controller) {
+							function pump():any {
+								return reader
+									?.read()
+									.then((chunk) => {
+                                        console.log("Chunk: ", chunk)
+
+                                        const decoder = new TextDecoder('utf-8')
+                                        const jsonString = decoder.decode(chunk.value)
+                                        
+                                        // console.log("JSON String: ", jsonString)
+
+                                        const parsedData = JSON.parse(jsonString)
+
+                                        console.log("Parsed Data: ", parsedData)
+
+										// When no more data needs to be consumed, close the stream
+										if (chunk.done) {
+											controller.close();
+											return;
+										}
+										// Enqueue the next data chunk into our target stream
+										controller.enqueue(chunk.value);
+										return pump();
+									});
+							}
+							return pump();
+						},
+					});
+				})
+				//   let data = await fetch(getFlaskBackendUrl() + "/streamData", {
+				//     method: "POST",
+				//     headers: {
+				//       "Content-Type": "application/json",
+				//     },
+				//     body: JSON.stringify({ expr: expr }),
+				//   }).then((res) => res.json());
+
+				if (data.success && !data.error) {
+					console.log("Data: ", data);
+					if (data.output) {
+						this.handleResponse({
+							type: "stdout",
+							value: data.output,
+						});
+					}
+					data = data.result;
+				} else {
+					throw Error(data.error);
+				}
+
+				// console.log("Resultant returned is: ", data)
+
+				if (!this.streamingActive) {
+					if (!data.done && data.result) {
+						// console.log("Still streaming data....")
+						if (data.result) {
+							console.log(
+								"(Flask) Still streaming data, but this value was returned: ",
+								data.result,
+							);
+						}
+						this.handleResponse({
+							type: "stream-data",
+							id,
+							value: JSON.stringify(data.result) as string,
+						});
+					}
+					break;
+				}
+
+				if (data.done) {
+					break;
+				}
+
+				console.log(
+					"(Flask) Done streaming data, the final value is....",
+					data,
+				);
+
+				this.handleResponse({
+					type: "stream-data",
+					id,
+					value: JSON.stringify(data) as string,
+				});
+			}
+		} catch (error) {
+			return this.runTracebackWithFlask(id, error);
+		} finally {
+			this.streamingActive = false;
+			console.log("Have completely finished streaming!");
+			this.handleResponse({ type: "stream-done", id });
+		}
+	}
 
 	// -------------------------------------------------------------------------
 	// Output Callbacks
@@ -481,7 +535,7 @@ export class FlaskBackend implements Backend {
 
 	private async handleRequest(request: BackendRequest) {
 		let { type, id, code, expr } = request;
-        id = "id" in request ? request.id as string : "";
+		id = "id" in request ? (request.id as string) : "";
 
 		switch (type) {
 			case "exec":
@@ -552,11 +606,13 @@ export class FlaskBackend implements Backend {
 				break;
 
 			case "stream-start":
-                if (!id || typeof expr !== "string") {
-                throw new Error("Invalid stream-start request: missing id or expr");
-                }
-                // Don't await - let it run autonomously
-                this.runStreamingLoop(id, expr);
+				if (!id || typeof expr !== "string") {
+					throw new Error(
+						"Invalid stream-start request: missing id or expr",
+					);
+				}
+				// Don't await - let it run autonomously
+				this.runStreamingLoop(id, expr);
 				break;
 
 			case "stream-exec":
@@ -567,10 +623,10 @@ export class FlaskBackend implements Backend {
 				break;
 
 			case "stream-stop":
-                this.streamingActive = false
+				this.streamingActive = false;
 				break;
-            default:
-                throw new Error(`Unknown message type: ${type}`);
+			default:
+				throw new Error(`Unknown message type: ${type}`);
 		}
 	}
 }

From 273c008f2de18b3e2088b718d66f022d359ffcf6 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 23 Jan 2026 16:46:01 -0500
Subject: [PATCH 30/39] Made some progress on reading the chunks from the Flask
 api endpoint stream

---
 src/lib/pyodide/backend/flask/backend.ts | 237 ++++++++++++-----------
 1 file changed, 128 insertions(+), 109 deletions(-)

diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 8bf5f481..00849503 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -241,139 +241,158 @@ export class FlaskBackend implements Backend {
 				);
 			}
 
-			while (this.streamingActive) {
-				// Execute any queued code first (for runtime parameter changes, events, etc.)
-				// Errors in queued code are reported but don't stop the simulation
-				while (this.streamingCodeQueue.length > 0) {
-					const code = this.streamingCodeQueue.shift()!;
-					try {
-						// Simply sending requests to the Flask api to execute code,
-						// we only really care if errors are produced so we don't handle any data response.
-						// There is also no need for streaming data here....
-
-						let data = await fetch(
-							getFlaskBackendUrl() + "/execute-code",
-							{
-								method: "POST",
-								headers: {
-									"Content-Type": "application/json",
-								},
-								body: JSON.stringify({ code: code }),
+			// Unlike the Pyodide version, we only need a while loop to go through commands that are queued up,
+			// It isn't necessary that we maintain a while loop while streaming as we are reading it with the fetch API
+
+			while (this.streamingCodeQueue.length > 0) {
+				const code = this.streamingCodeQueue.shift()!;
+				try {
+					// Simply sending requests to the Flask api to execute code,
+					// we only really care if errors are produced so we don't handle any data response.
+					// There is also no need for streaming data here....
+
+					let data = await fetch(
+						getFlaskBackendUrl() + "/execute-code",
+						{
+							method: "POST",
+							headers: {
+								"Content-Type": "application/json",
 							},
-						).then((res) => res.json());
-						if (data.success && data.output) {
-							this.handleResponse({
-								type: "stdout",
-								value: data.output,
-							});
-						} else {
-							throw Error(data.error);
-						}
-					} catch (error) {
-						const errorMsg =
-							error instanceof Error
-								? error.message
-								: String(error);
+							body: JSON.stringify({ code: code }),
+						},
+					).then((res) => res.json());
+					if (data.success && data.output) {
 						this.handleResponse({
-							type: "stderr",
-							value: `Stream exec error: ${errorMsg}`,
+							type: "stdout",
+							value: data.output,
 						});
+					} else {
+						throw Error(data.error);
 					}
+				} catch (error) {
+					const errorMsg =
+						error instanceof Error ? error.message : String(error);
+					this.handleResponse({
+						type: "stderr",
+						value: `Stream exec error: ${errorMsg}`,
+					});
 				}
+			}
+
+			console.log("Streaming code expression is: ", expr);
 
-				console.log("Streaming code expression is: ", expr);
+			let streaming = true;
 
-				let data = await fetch(
+			if (streaming) {
+				let stream = await fetch(
 					getFlaskBackendUrl() + "/streamData",
 				).then((res) => {
 					const reader = res.body?.getReader();
 					return new ReadableStream({
 						start(controller) {
-							function pump():any {
-								return reader
-									?.read()
-									.then((chunk) => {
-                                        console.log("Chunk: ", chunk)
-
-                                        const decoder = new TextDecoder('utf-8')
-                                        const jsonString = decoder.decode(chunk.value)
-                                        
-                                        // console.log("JSON String: ", jsonString)
-
-                                        const parsedData = JSON.parse(jsonString)
-
-                                        console.log("Parsed Data: ", parsedData)
-
-										// When no more data needs to be consumed, close the stream
-										if (chunk.done) {
-											controller.close();
-											return;
-										}
-										// Enqueue the next data chunk into our target stream
-										controller.enqueue(chunk.value);
-										return pump();
-									});
+							function pump(): any {
+								return reader?.read().then((chunk) => {
+									console.log("Chunk: ", chunk);
+
+									const decoder = new TextDecoder("utf-8");
+									const jsonString = decoder.decode(
+										chunk.value,
+									);
+
+									// console.log("JSON String: ", jsonString);
+
+									let data = JSON.parse(jsonString);
+
+									console.log("Parsed Data: ", data);
+
+									// When no more data needs to be consumed, close the stream
+									if (chunk.done) {
+										controller.close();
+										return;
+									}
+									// Enqueue the next data chunk into our target stream
+									controller.enqueue(chunk.value);
+									return pump();
+								});
 							}
 							return pump();
 						},
 					});
-				})
-				//   let data = await fetch(getFlaskBackendUrl() + "/streamData", {
-				//     method: "POST",
-				//     headers: {
-				//       "Content-Type": "application/json",
-				//     },
-				//     body: JSON.stringify({ expr: expr }),
-				//   }).then((res) => res.json());
-
-				if (data.success && !data.error) {
-					console.log("Data: ", data);
-					if (data.output) {
-						this.handleResponse({
-							type: "stdout",
-							value: data.output,
-						});
-					}
-					data = data.result;
-				} else {
-					throw Error(data.error);
-				}
+				});
+			} else {
+				// ---------------- OLD WAY OF FETCHING (without streaming) -----------------
 
-				// console.log("Resultant returned is: ", data)
+				while (this.streamingActive) {
+					let data = await fetch(
+						getFlaskBackendUrl() + "/evaluate-expression",
+						{
+							method: "POST",
+							headers: {
+								"Content-Type": "application/json",
+							},
+							body: JSON.stringify({ expr: expr }),
+						},
+					).then((res) => res.json());
+					// ---------------------------------------------------------------------------
 
-				if (!this.streamingActive) {
-					if (!data.done && data.result) {
-						// console.log("Still streaming data....")
-						if (data.result) {
-							console.log(
-								"(Flask) Still streaming data, but this value was returned: ",
-								data.result,
-							);
+					// ------- (Need to rework) DATA ERROR and SUCCESS HANDLING ------------------
+					if (data.success && !data.error) {
+						console.log("Data: ", data);
+						if (data.output) {
+							this.handleResponse({
+								type: "stdout",
+								value: data.output,
+							});
 						}
-						this.handleResponse({
-							type: "stream-data",
-							id,
-							value: JSON.stringify(data.result) as string,
-						});
+						data = data.result;
+					} else {
+						throw Error(data.error);
 					}
-					break;
-				}
+					// ---------------------------------------------------------------------------
+
+					// ------- (Need to rework) LOGIC ABOUT INACTIVE STREAMING SO THAT WE STOP ---
+					if (!this.streamingActive) {
+						if (!data.done && data.result) {
+							// console.log("Still streaming data....")
+							if (data.result) {
+								console.log(
+									"(Flask) Still streaming data, but this value was returned: ",
+									data.result,
+								);
+							}
+							this.handleResponse({
+								type: "stream-data",
+								id,
+								value: JSON.stringify(data.result) as string,
+							});
+						}
+						break;
+					}
+					// ---------------------------------------------------------------------------
 
-				if (data.done) {
-					break;
-				}
+					/* Subbed by the FLASK functionality ---------------
+					 * The Flask backend already handles the logic for looping until all data is concluded,
+					 * and it provides all the information in chunks */
 
-				console.log(
-					"(Flask) Done streaming data, the final value is....",
-					data,
-				);
+					if (data.done) {
+						break;
+					}
 
-				this.handleResponse({
-					type: "stream-data",
-					id,
-					value: JSON.stringify(data) as string,
-				});
+					console.log(
+						"(Flask) Done streaming data, the final value is....",
+						data,
+					);
+
+					this.handleResponse({
+						type: "stream-data",
+						id,
+						value: JSON.stringify(data) as string,
+					});
+				}
+
+				// --------------------------------------------------
 			}
+
 		} catch (error) {
 			return this.runTracebackWithFlask(id, error);
 		} finally {

From 8b5d3261067f93dfb2d5b7c43c04b1e0e6542122 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 28 Jan 2026 10:08:52 -0500
Subject: [PATCH 31/39] Added code that separates the responses since sometimes
 multiple API responses can be streamed within the same chunk

---
 src/lib/pyodide/backend/flask/backend.ts | 36 ++++++++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index f85ce884..70ee2fd6 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -296,12 +296,44 @@ export class FlaskBackend implements Backend {
 									console.log("Uint8Array for Chunk is ", chunk.value)
 
 									const decoder = new TextDecoder("utf-8");
-									const jsonString = decoder.decode(
+									let jsonString = decoder.decode(
 										chunk.value,
 									);
+									
+									console.log("Original JSON String: ", jsonString)
 
+									let individualResponses = []
+									const responseSubstr = "success"
 
-									console.log(jsonString)
+									/* Sometimes within the same chunk I'll receive more than one API response
+									 * such that it appears liked jsonString = "{"success":...,"data":...}{"success":...,"data":...}"
+									 * so we need to take the time to break it up into its individual requests
+									 * */
+
+									let doneBreakingUp = false
+
+									while(jsonString.indexOf(responseSubstr) && !doneBreakingUp) {
+										let firstIndex = jsonString.indexOf(responseSubstr)
+
+										let remainingString = jsonString.slice(firstIndex+responseSubstr.length, jsonString.length)
+										let secondIndex = remainingString.indexOf(responseSubstr)
+
+										// console.log(`First index: ${firstIndex}, Second index: ${secondIndex}`)
+
+										if(secondIndex == -1 || firstIndex == -1) {
+											individualResponses.push(jsonString)
+											console.log("Adding response: ", jsonString)
+											doneBreakingUp = true
+										} else {
+											let request = jsonString.slice(firstIndex-2, firstIndex+responseSubstr.length+secondIndex-2)
+											console.log("Adding response: ", request)
+											individualResponses.push(request)
+											jsonString = jsonString.slice(firstIndex+responseSubstr.length+secondIndex-2, jsonString.length)
+										}
+									}
+
+
+									console.log("The individual responses from the string are: ", individualResponses)
 
 									// console.log("JSON String: ", jsonString);
 

From c9380d3a2922a834d06ef55a1804510dbe2240b8 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 28 Jan 2026 11:32:36 -0500
Subject: [PATCH 32/39] Asynchronously handling data chunks now, the intiial
 continue function works but the continuation function is off

---
 src/lib/pyodide/backend/flask/backend.ts | 167 +++++++++++++----------
 1 file changed, 93 insertions(+), 74 deletions(-)

diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 70ee2fd6..57bad0d9 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -284,81 +284,101 @@ export class FlaskBackend implements Backend {
 			let streaming = true;
 
 			if (streaming) {
-				let stream = await fetch(
+				let streamingData: object[] = [];
+				let response = await fetch(
 					getFlaskBackendUrl() + "/streamData",
-				).then((res) => {
-					const reader = res.body?.getReader();
-					return new ReadableStream({
-						start(controller) {
-							function pump(): any {
-								return reader?.read().then((chunk) => {
-									console.log("Chunk: ", chunk);
-									console.log("Uint8Array for Chunk is ", chunk.value)
-
-									const decoder = new TextDecoder("utf-8");
-									let jsonString = decoder.decode(
-										chunk.value,
-									);
-									
-									console.log("Original JSON String: ", jsonString)
-
-									let individualResponses = []
-									const responseSubstr = "success"
-
-									/* Sometimes within the same chunk I'll receive more than one API response
-									 * such that it appears liked jsonString = "{"success":...,"data":...}{"success":...,"data":...}"
-									 * so we need to take the time to break it up into its individual requests
-									 * */
-
-									let doneBreakingUp = false
-
-									while(jsonString.indexOf(responseSubstr) && !doneBreakingUp) {
-										let firstIndex = jsonString.indexOf(responseSubstr)
-
-										let remainingString = jsonString.slice(firstIndex+responseSubstr.length, jsonString.length)
-										let secondIndex = remainingString.indexOf(responseSubstr)
-
-										// console.log(`First index: ${firstIndex}, Second index: ${secondIndex}`)
-
-										if(secondIndex == -1 || firstIndex == -1) {
-											individualResponses.push(jsonString)
-											console.log("Adding response: ", jsonString)
-											doneBreakingUp = true
-										} else {
-											let request = jsonString.slice(firstIndex-2, firstIndex+responseSubstr.length+secondIndex-2)
-											console.log("Adding response: ", request)
-											individualResponses.push(request)
-											jsonString = jsonString.slice(firstIndex+responseSubstr.length+secondIndex-2, jsonString.length)
-										}
-									}
-
-
-									console.log("The individual responses from the string are: ", individualResponses)
-
-									// console.log("JSON String: ", jsonString);
-
-									try {
-										let data = JSON.parse(jsonString);
-										console.log("Parsed Data: ", data);
-									} catch (error) {
-										console.log("We encountered an error: ", error)
-									}
-
-
-									// When no more data needs to be consumed, close the stream
-									if (chunk.done) {
-										controller.close();
-										return;
-									}
-									// Enqueue the next data chunk into our target stream
-									controller.enqueue(chunk.value);
-									return pump();
-								});
+				);
+
+				console.log(
+					"We have begun asynchronously reading the readable stream",
+				);
+
+				let individualResponses:string[] = [];
+
+				if (response.body) {
+					for await (const chunk of response.body) {
+
+						const decoder = new TextDecoder("utf-8");
+						let jsonString = decoder.decode(chunk);
+
+						const responseSubstr = "success";
+
+						/* Sometimes within the same chunk I'll receive more than one API response
+						 * such that it appears liked jsonString = "{"success":...,"data":...}{"success":...,"data":...}"
+						 * so we need to take the time to break it up into its individual requests
+						 * */
+
+						let doneBreakingUp = false;
+
+						while (
+							jsonString.indexOf(responseSubstr) &&
+							!doneBreakingUp
+						) {
+							let firstIndex = jsonString.indexOf(responseSubstr);
+
+							let remainingString = jsonString.slice(
+								firstIndex + responseSubstr.length,
+								jsonString.length,
+							);
+							let secondIndex =
+								remainingString.indexOf(responseSubstr);
+
+							// console.log(`First index: ${firstIndex}, Second index: ${secondIndex}`)
+
+							if (secondIndex == -1 || firstIndex == -1) {
+								individualResponses.push(jsonString);
+								// console.log("Adding response: ", jsonString)
+								doneBreakingUp = true;
+							} else {
+								let request = jsonString.slice(
+									firstIndex - 2,
+									firstIndex +
+										responseSubstr.length +
+										secondIndex -
+										2,
+								);
+								// console.log("Adding response: ", request)
+								individualResponses.push(request);
+								jsonString = jsonString.slice(
+									firstIndex +
+										responseSubstr.length +
+										secondIndex -
+										2,
+									jsonString.length,
+								);
 							}
-							return pump();
-						},
-					});
-				});
+						}
+					}
+
+					
+					console.log("The individual responses are: ", individualResponses)
+
+					let dataChunks = individualResponses.flatMap((res) => {
+						let parsedResponse = JSON.parse(res)
+						console.log("Done status is: ", parsedResponse.result.done)
+						if(parsedResponse.success && !parsedResponse.result.done && parsedResponse.result.result) {
+							return parsedResponse
+						} else {
+							return []
+						}
+					})
+					
+					console.log(
+						"The data chunks are: ",
+						dataChunks
+					);
+
+					for(let dataChunk of dataChunks) {
+						console.log("Passing through stream data: ", dataChunk.result)
+						this.handleResponse({
+							type: "stream-data",
+							id,
+							value: JSON.stringify(dataChunk.result) as string
+						})
+					}
+				}
+
+				console.log("We have closed the readable stream");
 			} else {
 				// ---------------- OLD WAY OF FETCHING (without streaming) -----------------
 
@@ -432,7 +452,6 @@ export class FlaskBackend implements Backend {
 
 				// --------------------------------------------------
 			}
-
 		} catch (error) {
 			return this.runTracebackWithFlask(id, error);
 		} finally {

From 53ab0c7bb3e4ef1910525e5a3c145c84b22bd14a Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 28 Jan 2026 11:40:41 -0500
Subject: [PATCH 33/39] Changed the sequential order of the stream-data passing
 code, so now it properly runs and continues the stream. This is lightning
 fast now!

---
 src/lib/pyodide/backend/flask/backend.ts | 61 +++++++++++++-----------
 1 file changed, 33 insertions(+), 28 deletions(-)

diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 57bad0d9..92a49893 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -293,10 +293,11 @@ export class FlaskBackend implements Backend {
 					"We have begun asynchronously reading the readable stream",
 				);
 
-				let individualResponses:string[] = [];
+				let individualResponses: string[] = [];
 
 				if (response.body) {
 					for await (const chunk of response.body) {
+						let resArray: string[] = [];
 
 						const decoder = new TextDecoder("utf-8");
 						let jsonString = decoder.decode(chunk);
@@ -326,7 +327,7 @@ export class FlaskBackend implements Backend {
 							// console.log(`First index: ${firstIndex}, Second index: ${secondIndex}`)
 
 							if (secondIndex == -1 || firstIndex == -1) {
-								individualResponses.push(jsonString);
+								resArray.push(jsonString);
 								// console.log("Adding response: ", jsonString)
 								doneBreakingUp = true;
 							} else {
@@ -338,7 +339,7 @@ export class FlaskBackend implements Backend {
 										2,
 								);
 								// console.log("Adding response: ", request)
-								individualResponses.push(request);
+								resArray.push(request);
 								jsonString = jsonString.slice(
 									firstIndex +
 										responseSubstr.length +
@@ -348,33 +349,37 @@ export class FlaskBackend implements Backend {
 								);
 							}
 						}
-					}
-
-					
-					console.log("The individual responses are: ", individualResponses)
 
-					let dataChunks = individualResponses.flatMap((res) => {
-						let parsedResponse = JSON.parse(res)
-						console.log("Done status is: ", parsedResponse.result.done)
-						if(parsedResponse.success && !parsedResponse.result.done && parsedResponse.result.result) {
-							return parsedResponse
-						} else {
-							return []
+						let dataChunks = resArray.flatMap((res) => {
+							let parsedResponse = JSON.parse(res);
+							console.log(
+								"Done status is: ",
+								parsedResponse.result.done,
+							);
+							if (
+								parsedResponse.success &&
+								!parsedResponse.result.done &&
+								parsedResponse.result.result
+							) {
+								return parsedResponse;
+							} else {
+								return [];
+							}
+						});
+						
+						for (let dataChunk of dataChunks) {
+							console.log(
+								"Passing through stream data: ",
+								dataChunk.result,
+							);
+							this.handleResponse({
+								type: "stream-data",
+								id,
+								value: JSON.stringify(
+									dataChunk.result,
+								) as string,
+							});
 						}
-					})
-					
-					console.log(
-						"The data chunks are: ",
-						dataChunks
-					);
-
-					for(let dataChunk of dataChunks) {
-						console.log("Passing through stream data: ", dataChunk.result)
-						this.handleResponse({
-							type: "stream-data",
-							id,
-							value: JSON.stringify(dataChunk.result) as string
-						})
 					}
 				}
 

From d022eef1775f98078a2fd6cd8882e524b004a8c4 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 28 Jan 2026 12:25:31 -0500
Subject: [PATCH 34/39] The streaming code works fairly efficiently now

---
 src/lib/pyodide/backend/flask/backend.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 92a49893..939499cb 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -366,7 +366,7 @@ export class FlaskBackend implements Backend {
 								return [];
 							}
 						});
-						
+
 						for (let dataChunk of dataChunks) {
 							console.log(
 								"Passing through stream data: ",

From 44c82af2c9383f434a74fd2bc0860c8d83a995b2 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 28 Jan 2026 12:40:09 -0500
Subject: [PATCH 35/39] Removed all the logs that I added, and removed some
 unnecessary zombie code

---
 src/lib/pyodide/backend/flask/backend.ts   | 244 +++++----------------
 src/lib/pyodide/backend/pyodide/backend.ts |  18 +-
 src/lib/pyodide/backend/pyodide/worker.ts  |  17 +-
 src/lib/pyodide/backend/registry.ts        |   6 -
 src/lib/stores/backendPreference.ts        |   2 -
 src/lib/stores/theme.ts                    |   6 +-
 src/routes/+page.svelte                    |  29 +--
 7 files changed, 63 insertions(+), 259 deletions(-)

diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 939499cb..d2d25e9c 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -69,16 +69,11 @@ export class FlaskBackend implements Backend {
 		const state = this.getState();
 		if (state.initialized || state.loading) return;
 
-		console.log(
-			"We are ready, this is a flask web server so we don't concern with initialization. Our only concern is whether the server is currently running.",
-		);
 		this.handleResponse({
 			type: "stdout",
 			value: "Your backend preference has been set to a Flask web server, initialization has already occured",
 		});
 
-		console.log("Concluded intialziation state change");
-
 		this.handleResponse({ type: "ready" });
 	}
 
@@ -120,7 +115,6 @@ export class FlaskBackend implements Backend {
 
 		return new Promise<void>((resolve, reject) => {
 			const timeoutId = setTimeout(() => {
-				console.log("Timeout triggered");
 				if (this.pendingRequests.has(id)) {
 					this.pendingRequests.delete(id);
 					reject(new Error("Execution timeout"));
@@ -160,10 +154,6 @@ export class FlaskBackend implements Backend {
 					try {
 						resolve(JSON.parse(value) as T);
 					} catch {
-						console.log(
-							"Error in evaluating the expression:",
-							value,
-						);
 						reject(
 							new Error(`Failed to parse eval result: ${value}`),
 						);
@@ -232,15 +222,6 @@ export class FlaskBackend implements Backend {
 
 			this.streamingCodeQueue.length = 0;
 
-			if (this.streamingCodeQueue.length == 0) {
-				console.log("Streaming code queue is empty...");
-			} else {
-				console.log(
-					"There is something in the streaming code queue...",
-					this.streamingCodeQueue,
-				);
-			}
-
 			// Unlike the Pyodide version, we only need a while loop to go through commands that are queued up,
 			// It isn't necessary that we maintain a while loop while streaming as we are reading it with the fetch API
 
@@ -279,189 +260,85 @@ export class FlaskBackend implements Backend {
 				}
 			}
 
-			console.log("Streaming code expression is: ", expr);
+			let response = await fetch(getFlaskBackendUrl() + "/streamData");
 
-			let streaming = true;
+			if (response.body) {
+				for await (const chunk of response.body) {
+					let resArray: string[] = [];
 
-			if (streaming) {
-				let streamingData: object[] = [];
-				let response = await fetch(
-					getFlaskBackendUrl() + "/streamData",
-				);
+					const decoder = new TextDecoder("utf-8");
+					let jsonString = decoder.decode(chunk);
 
-				console.log(
-					"We have begun asynchronously reading the readable stream",
-				);
+					const responseSubstr = "success";
 
-				let individualResponses: string[] = [];
+					/* Sometimes within the same chunk I'll receive more than one API response
+					 * such that it appears liked jsonString = "{"success":...,"data":...}{"success":...,"data":...}"
+					 * so we need to take the time to break it up into its individual requests
+					 * */
 
-				if (response.body) {
-					for await (const chunk of response.body) {
-						let resArray: string[] = [];
+					let doneBreakingUp = false;
 
-						const decoder = new TextDecoder("utf-8");
-						let jsonString = decoder.decode(chunk);
+					while (
+						jsonString.indexOf(responseSubstr) &&
+						!doneBreakingUp
+					) {
+						let firstIndex = jsonString.indexOf(responseSubstr);
 
-						const responseSubstr = "success";
-
-						/* Sometimes within the same chunk I'll receive more than one API response
-						 * such that it appears liked jsonString = "{"success":...,"data":...}{"success":...,"data":...}"
-						 * so we need to take the time to break it up into its individual requests
-						 * */
-
-						let doneBreakingUp = false;
-
-						while (
-							jsonString.indexOf(responseSubstr) &&
-							!doneBreakingUp
-						) {
-							let firstIndex = jsonString.indexOf(responseSubstr);
-
-							let remainingString = jsonString.slice(
-								firstIndex + responseSubstr.length,
-								jsonString.length,
-							);
-							let secondIndex =
-								remainingString.indexOf(responseSubstr);
-
-							// console.log(`First index: ${firstIndex}, Second index: ${secondIndex}`)
-
-							if (secondIndex == -1 || firstIndex == -1) {
-								resArray.push(jsonString);
-								// console.log("Adding response: ", jsonString)
-								doneBreakingUp = true;
-							} else {
-								let request = jsonString.slice(
-									firstIndex - 2,
-									firstIndex +
-										responseSubstr.length +
-										secondIndex -
-										2,
-								);
-								// console.log("Adding response: ", request)
-								resArray.push(request);
-								jsonString = jsonString.slice(
-									firstIndex +
-										responseSubstr.length +
-										secondIndex -
-										2,
-									jsonString.length,
-								);
-							}
-						}
-
-						let dataChunks = resArray.flatMap((res) => {
-							let parsedResponse = JSON.parse(res);
-							console.log(
-								"Done status is: ",
-								parsedResponse.result.done,
+						let remainingString = jsonString.slice(
+							firstIndex + responseSubstr.length,
+							jsonString.length,
+						);
+						let secondIndex =
+							remainingString.indexOf(responseSubstr);
+
+						if (secondIndex == -1 || firstIndex == -1) {
+							resArray.push(jsonString);
+							doneBreakingUp = true;
+						} else {
+							let request = jsonString.slice(
+								firstIndex - 2,
+								firstIndex +
+									responseSubstr.length +
+									secondIndex -
+									2,
 							);
-							if (
-								parsedResponse.success &&
-								!parsedResponse.result.done &&
-								parsedResponse.result.result
-							) {
-								return parsedResponse;
-							} else {
-								return [];
-							}
-						});
-
-						for (let dataChunk of dataChunks) {
-							console.log(
-								"Passing through stream data: ",
-								dataChunk.result,
+							resArray.push(request);
+							jsonString = jsonString.slice(
+								firstIndex +
+									responseSubstr.length +
+									secondIndex -
+									2,
+								jsonString.length,
 							);
-							this.handleResponse({
-								type: "stream-data",
-								id,
-								value: JSON.stringify(
-									dataChunk.result,
-								) as string,
-							});
 						}
 					}
-				}
-
-				console.log("We have closed the readable stream");
-			} else {
-				// ---------------- OLD WAY OF FETCHING (without streaming) -----------------
-
-				while (this.streamingActive) {
-					let data = await fetch(
-						getFlaskBackendUrl() + "/evaluate-expression",
-						{
-							method: "POST",
-							headers: {
-								"Content-Type": "application/json",
-							},
-							body: JSON.stringify({ expr: expr }),
-						},
-					).then((res) => res.json());
-					// ---------------------------------------------------------------------------
 
-					// ------- (Need to rework) DATA ERROR and SUCCESS HANDLING ------------------
-					if (data.success && !data.error) {
-						console.log("Data: ", data);
-						if (data.output) {
-							this.handleResponse({
-								type: "stdout",
-								value: data.output,
-							});
-						}
-						data = data.result;
-					} else {
-						throw Error(data.error);
-					}
-					// ---------------------------------------------------------------------------
-
-					// ------- (Need to rework) LOGIC ABOUT INACTIVE STREAMING SO THAT WE STOP ---
-					if (!this.streamingActive) {
-						if (!data.done && data.result) {
-							// console.log("Still streaming data....")
-							if (data.result) {
-								console.log(
-									"(Flask) Still streaming data, but this value was returned: ",
-									data.result,
-								);
-							}
-							this.handleResponse({
-								type: "stream-data",
-								id,
-								value: JSON.stringify(data.result) as string,
-							});
+					let dataChunks = resArray.flatMap((res) => {
+						let parsedResponse = JSON.parse(res);
+						if (
+							parsedResponse.success &&
+							!parsedResponse.result.done &&
+							parsedResponse.result.result
+						) {
+							return parsedResponse;
+						} else {
+							return [];
 						}
-						break;
-					}
-					// ---------------------------------------------------------------------------
-
-					/* Subbed by the FLASK functionality ---------------
-					 * The Flask backend already handles the logic for looping until all data is concluded,
-					 * and it provides all the information in chunks */
+					});
 
-					if (data.done) {
-						break;
+					for (let dataChunk of dataChunks) {
+						this.handleResponse({
+							type: "stream-data",
+							id,
+							value: JSON.stringify(dataChunk.result) as string,
+						});
 					}
-
-					console.log(
-						"(Flask) Done streaming data, the final value is....",
-						data,
-					);
-
-					this.handleResponse({
-						type: "stream-data",
-						id,
-						value: JSON.stringify(data) as string,
-					});
 				}
-
-				// --------------------------------------------------
 			}
 		} catch (error) {
 			return this.runTracebackWithFlask(id, error);
 		} finally {
 			this.streamingActive = false;
-			console.log("Have completely finished streaming!");
 			this.handleResponse({ type: "stream-done", id });
 		}
 	}
@@ -670,11 +547,6 @@ export class FlaskBackend implements Backend {
 								value: data.output,
 							});
 						}
-						console.log(
-							"\n\n(Flask) The evaluated result from evaluating the expression: ",
-							JSON.stringify(data.result),
-							"\n\n",
-						);
 						this.handleResponse({
 							type: "value",
 							id,
diff --git a/src/lib/pyodide/backend/pyodide/backend.ts b/src/lib/pyodide/backend/pyodide/backend.ts
index ce6b3da0..f88466ce 100644
--- a/src/lib/pyodide/backend/pyodide/backend.ts
+++ b/src/lib/pyodide/backend/pyodide/backend.ts
@@ -7,7 +7,6 @@ import type { Backend, BackendState, REPLRequest, REPLResponse, REPLErrorRespons
 import { backendState } from '../state';
 import { TIMEOUTS } from '$lib/constants/python';
 import { PROGRESS_MESSAGES, STATUS_MESSAGES } from '$lib/constants/messages';
-import type { BackendPreference } from '$lib/types';
 
 interface PendingRequest {
 	resolve: (value: string | undefined) => void;
@@ -33,7 +32,6 @@ export class PyodideBackend implements Backend {
 	private messageId = 0;
 	private pendingRequests = new Map<string, PendingRequest>();
 	private isInitializing = false;
-	private backendPreference : null | BackendPreference = "pyodide";
 
 	private streamState: StreamState = {
 		id: null,
@@ -73,15 +71,12 @@ export class PyodideBackend implements Backend {
 		this.isInitializing = true;
 
 		try {
-			console.log("(backend.ts, init) The backend preference is: ", this.backendPreference)
 			this.worker = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' });
 
 			this.worker.onmessage = (event: MessageEvent<REPLResponse>) => {
 				this.handleResponse(event.data);
 			};
 
-			console.log("The worker is: ", this.worker)
-
 			this.worker.onerror = (event) => {
 				backendState.update((s) => ({
 					...s,
@@ -91,7 +86,7 @@ export class PyodideBackend implements Backend {
 			};
 
 			// Send init message
-			this.sendRequest({ type: 'init', backendPreference: this.backendPreference });
+			this.sendRequest({ type: 'init' });
 
 			// Wait for ready
 			await new Promise<void>((resolve, reject) => {
@@ -234,7 +229,6 @@ export class PyodideBackend implements Backend {
 					try {
 						resolve(JSON.parse(value) as T);
 					} catch {
-						console.log("Error in evaluating the expression:", value)
 						reject(new Error(`Failed to parse eval result: ${value}`));
 					}
 				},
@@ -323,7 +317,6 @@ export class PyodideBackend implements Backend {
 
 	private sendRequest(request: REPLRequest): void {
 		if (!this.worker) {
-			console.log(`Within sendRequest() I have an uninitialized worker!`) // Debugging console
 			throw new Error('Worker not initialized');
 		}
 		this.worker.postMessage(request);
@@ -432,13 +425,4 @@ export class PyodideBackend implements Backend {
 
 		backendState.update((s) => ({ ...s, error: error || 'Unknown error' }));
 	}
-
-	setBackendPreference(currentBackendPreference : null | BackendPreference):void {
-		console.log("(backend.ts) Setting backend preference: ", currentBackendPreference)
-		this.backendPreference = currentBackendPreference
-	}
-
-	getBackendPreference(): null | BackendPreference {
-		return this.backendPreference
-	}
 }
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 4eb9a454..0e3ed79a 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -102,7 +102,6 @@ print(f"${pkg.import} {${pkg.import}.__version__} loaded successfully")
 async function execCode(id: string, code: string): Promise<void> {
     // Default to pyodide use
     if (!pyodide) {
-      console.log(`Within execCode() I have an uninitialized worker!`); // Debugging console
       throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
     }
     try {
@@ -132,7 +131,6 @@ traceback.format_exc()
 async function evalExpr(id: string, expr: string): Promise<void> {
     // Default to pyodide use
     if (!pyodide) {
-      console.log(`Within evalExpr() I have an uninitialized worker!`); // Debugging console
       throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
     }
 
@@ -141,11 +139,6 @@ async function evalExpr(id: string, expr: string): Promise<void> {
 _eval_result = ${expr}
 json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
 		`);
-      console.log(
-        "\n\n(Pyodide) The evaluated result from evaluating the expression: ",
-        result,
-        "\n\n",
-      );
       send({ type: "value", id, value: result as string });
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -169,7 +162,6 @@ traceback.format_exc()
  */
 async function runStreamingLoop(id: string, expr: string): Promise<void> {
     if (!pyodide) {
-      console.log(`Within runStreamingLoop() I have an uninitialized worker!`); // Debugging console
       throw new Error(ERROR_MESSAGES.WORKER_NOT_INITIALIZED);
     }
 
@@ -192,8 +184,6 @@ async function runStreamingLoop(id: string, expr: string): Promise<void> {
           }
         }
 
-        console.log(`(Pyodide) The expression being sent is: `, expr)
-
         // Step the generator
         const result = await pyodide.runPythonAsync(`
 _eval_result = ${expr}
@@ -215,12 +205,7 @@ json.dumps(_eval_result, default=_to_json if '_to_json' in dir() else str)
         if (parsed.done) {
           break;
         }
-
-        // Send result and continue
-        console.log(
-          "(Pyodide) Done streaming data, the final value is....",
-          JSON.parse(result as string)
-        );
+        
         send({ type: "stream-data", id, value: result as string });
       }
     } catch (error) {
diff --git a/src/lib/pyodide/backend/registry.ts b/src/lib/pyodide/backend/registry.ts
index 68ecf5da..4c68cf06 100644
--- a/src/lib/pyodide/backend/registry.ts
+++ b/src/lib/pyodide/backend/registry.ts
@@ -33,17 +33,12 @@ export function getBackend(): Backend {
  * Create a backend by type
  */
 export function createBackend(type: null |  BackendPreference): Backend {
-	console.log("(registry.ts, createBackend) Current Backend Preference is: ", type)
 	switch (type) {
 		case 'pyodide':
 		case null:
 			return new PyodideBackend();
 		case 'flask':
-			// let backend = new PyodideBackend()
-			// backend.setBackendPreference("flask")
 			return new FlaskBackend()
-		// case 'remote':
-		// 	throw new Error(`Backend type '${type}' not yet implemented`);
 		default:
 			throw new Error(`Unknown backend type: ${type}`);
 	}
@@ -54,7 +49,6 @@ export function createBackend(type: null |  BackendPreference): Backend {
  * Terminates the current backend before creating the new one
  */
 export function switchBackend(type: BackendPreference | null): Backend {
-	console.log("(registry.ts, switchBackend) Switching backend type to ", type)
 	if (currentBackend) {
 		currentBackend.terminate();
 	}
diff --git a/src/lib/stores/backendPreference.ts b/src/lib/stores/backendPreference.ts
index ff01e7d6..573f85cd 100644
--- a/src/lib/stores/backendPreference.ts
+++ b/src/lib/stores/backendPreference.ts
@@ -41,9 +41,7 @@ export const backendPreferenceStore = {
 	 * Toggle between a preference for flask or pyodide
 	 */
 	toggle(): void {
-		console.log(`Value (Before), ${this.get()}`)
 		backendPreference.update((current) => (current === 'pyodide' ? 'flask' : 'pyodide'));
-		console.log(`Value (After), ${this.get()}`)
 		switchBackend(this.get())
 	},
 
diff --git a/src/lib/stores/theme.ts b/src/lib/stores/theme.ts
index f23925f0..21c2b989 100644
--- a/src/lib/stores/theme.ts
+++ b/src/lib/stores/theme.ts
@@ -11,11 +11,7 @@ export type Theme = 'light' | 'dark';
 // Get initial theme from localStorage or system preference
 function getInitialTheme(): Theme {
 	if (!browser || typeof window == "undefined") return 'dark';
-
-	console.log(`Are we running on the browser?`, browser)
-	console.log("Local Storage type is ", typeof localStorage)
-	console.log("Window type is ", typeof window)
-	console.log(`Local Storage object:`, localStorage)
+	
 	const stored = localStorage.getItem('pathview-theme');
 	if (stored === 'light' || stored === 'dark') {
 		return stored;
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 27ce8b6c..9cada15a 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -426,12 +426,10 @@
 		});
 
 		const unsubTheme = themeStore.subscribe((theme) => {
-			console.log("Unsubscribing from the theme store")
 			currentTheme = theme;
 		});
 
 		const unsubBackendPreference = backendPreferenceStore.subscribe((backendPreference) => {
-			console.log("Unsubscribing from the backend preference store")
 			currentBackendPreference = backendPreference
 		})
 
@@ -769,7 +767,6 @@
 	// Run simulation (auto-initializes if needed) - Interacts with "backend"
 	async function handleRun() {
 		// Logging the current backend preference
-		console.log(`(+page.svelte) The current backend preference is ${currentBackendPreference}`)
 
 		let usingPyodide = currentBackendPreference == "pyodide"
 
@@ -786,7 +783,6 @@
 		// Auto-initialize if not ready
 		if (!pyodideReady && usingPyodide) {
 			try {
-				console.log("Initializing Pyodide")
 				await initPyodide();
 			} catch (error) {
 				console.error('Failed to initialize Pyodide:', error);
@@ -817,29 +813,9 @@
 				statusText = 'Validating...';
 
 				let validation
-
-				// if(usingPyodide) {
+				
 				validation = await validateGraphSimulation(nodes, codeContext);
-				// } else {
-				// 	console.log("[Sending to Flask web server] The node registry is: ", nodeRegistry.getAll())
-				// 	let fetchedData = await fetch(getFlaskBackendUrl()+"/validateGraphSimulation", {
-				// 		method: "POST",
-				// 		body: JSON.stringify({
-				// 			nodes,
-				// 			codeContext,
-				// 			nodeRegistryNodes: nodeRegistry.getAll() // It is necessary to pass in the node registry to the backend since it doesn't have it
-				// 		}),
-				// 		headers: {
-				// 			"Content-Type":"application/json"
-				// 		}
-				// 	}).then(res => res.json())
-				// 	if(!fetchedData.success) {
-				// 		throw Error(fetchedData.error)
-				// 	} else {
-				// 		validation = fetchedData.data satisfies ValidationResult
-				// 	}
-				// }
-
+				
 				if (!validation.valid) {
 					// Show validation errors
 					showConsole = true;
@@ -867,7 +843,6 @@
 			// Run streaming simulation
 			try {
 				const events = eventStore.toJSON();
-				console.log("-- Starting STREAMING --")
 				await runGraphStreamingSimulation(
 					nodes,
 					connections,

From c96ce8898993a9fff731504d130c3a603e396f97 Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Wed, 28 Jan 2026 16:29:55 -0500
Subject: [PATCH 36/39] Trying to implement a system that saves namespace in
 session, there is currently an issue with the 'quit' and 'exit' and
 'copyright' properties of the namespace since they aren't encapsulated in
 quotes sadly

---
 .gitignore                               |  1 +
 requirements.txt                         |  3 +-
 src/backend.py                           | 80 ++++++++++++++++++------
 src/lib/pyodide/backend/flask/backend.ts | 34 ++++++++--
 src/lib/utils/flaskRoutes.ts             |  2 +-
 5 files changed, 95 insertions(+), 25 deletions(-)

diff --git a/.gitignore b/.gitignore
index 91d8dfa3..13ed74f9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,3 +38,4 @@ tmpclaude-*
 
 
 __pycache__/
+src/example.py
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 74efc233..9b3a6938 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,4 +4,5 @@ flask-cors>=6.0.1
 
 numpy
 pathsim
-pathsim_chem
\ No newline at end of file
+pathsim_chem
+dotenv
\ No newline at end of file
diff --git a/src/backend.py b/src/backend.py
index 7ff903ba..4a5393d6 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -2,8 +2,11 @@
 import json
 import traceback
 import requests as req
-from flask import Flask, request, jsonify, Response, stream_with_context
+from flask import Flask, request, jsonify, Response, stream_with_context, session
 from flask_cors import CORS
+from dotenv import load_dotenv
+import argparse
+from types import SimpleNamespace
 
 import io
 from contextlib import redirect_stdout, redirect_stderr
@@ -19,7 +22,6 @@
 STREAMING_STEP_EXPR = "_step_streaming_gen()"
 
 _clean_globals = set(globals().keys())
-namespace = {}
 
 '''
 The Flask web server would not be initialized simultaneously with the SvelteKit website since the latter is statically generated,
@@ -27,8 +29,10 @@
 "https://view.pathsim.org" (which I think is already encapsualted by the "*" in the CORS.resources.options parameter)
 '''
 
+load_dotenv()
 
 app = Flask(__name__, static_folder="../static", static_url_path="")
+app.secret_key = os.getenv("SECRET_KEY")
 
 if os.getenv("FLASK_ENV") == "production":
     CORS(app,
@@ -51,6 +55,25 @@
         supports_credentials=True
     )
 
+@app.route("/initialize", methods=["GET"])
+def intialize():
+    # The purpose of initialization in Flask is s8imply just to clear the current namespace!
+    try:
+        session["namespace"] = json.dumps({})
+        print("Successfully reset session namespace")
+        return jsonify({
+            "success": True
+        })
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": e
+        }), 400
+
+@app.route("/namespaceCheck", methods=["GET"])
+def namespaceCheck():
+    return jsonify({"namespace": session["namespace"]})
+
 # Execute Python route copied from the previous repository
 @app.route("/execute-code", methods=["POST"])
 def execute_code():
@@ -64,7 +87,13 @@ def execute_code():
             return jsonify({"success": False, "error": "No code provided"}), 400
 
         # Create a temporary namespace that includes current eval_namespace
-        # temp_namespace = {}
+        temp_namespace = {}
+        if "namespace" in session:
+            app.logger.info("We have a temporary namespace in session...")
+            temp_namespace = session["namespace"]
+        else:
+            app.logger.info("We are instantiating an empty namespace...")
+            temp_namespace = {}
         # temp_namespace.update(globals())
 
         # Capture stdout and stderr
@@ -73,8 +102,16 @@ def execute_code():
 
         try:
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                exec(code, namespace)
-
+                exec(code, globals=globals(), locals= temp_namespace)
+            
+            app.logger.info(type(temp_namespace))
+            app.logger.info(temp_namespace)
+            app.logger.info("Stringified Dictionary: ", str(temp_namespace))
+            # app.logger.info("Temporary Namespace:")
+            # app.logger.info(json.dumps(temp_namespace))
+            # jsonString = json.dumps(temp_namespace)
+            session["namespace"] = repr(temp_namespace)
+            # app.logger.info("What we return is: ", jsonString)
             # Capture any output
             output = stdout_capture.getvalue()
             error_output = stderr_capture.getvalue()
@@ -107,6 +144,12 @@ def evaluate_expression():
         if not expr.strip():
             return jsonify({"success": False, "error": "No Python expression provided"}), 400
         
+        temp_namespace = {}
+
+        if "namespace" in session:
+            temp_namespace = session["namespace"]
+        else:
+            temp_namespace = {}
 
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
@@ -114,7 +157,9 @@ def evaluate_expression():
         try:
             result = ""
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                result = eval(expr, namespace)
+                result = eval(expr, temp_namespace)
+
+            session["namespace"] = json.dumps(SimpleNamespace(temp_namespace))
 
             # Capture any output
             output = stdout_capture.getvalue()
@@ -150,30 +195,32 @@ def check_traceback():
 @app.route("/streamData", methods=["POST", "GET"])
 def stream_data():
     def generate(expr):
+
+        temp_namespace = {}
+        if "namespace" in session:
+            temp_namespace = session["namespace"]
+        else:
+            temp_namespace = {}
+
         # Capture stdout and stderror
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
 
         isDone = False
-        count = 0
         
         while not isDone:
-            print("(Generator) Count: ", count)
-            # print("Generator expression is: ", expr)
-            # yield json.dumps({"name": "Ayo", "age": 18})
 
             result = " "
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                result = eval(expr, namespace)
-        
-            print("Is the result done? ", result["done"])
+                result = eval(expr, temp_namespace)
+
+            session["namespace"] = json.dumps(SimpleNamespace(temp_namespace))
 
             # Capture any output
             output = stdout_capture.getvalue()
             error_output = stderr_capture.getvalue()
 
             if error_output:
-                print("Oh no there was an error ;-;")
                 return jsonify({"success": False, "error": error_output})
             
             # Directly responding with a Flask Response object (as jsonify(...) does) doesn't work
@@ -188,10 +235,7 @@ def generate(expr):
                 }
             )
 
-            count += 1
-
             if result["done"]:
-                print("Concluding the while loop!")
                 isDone = True
     
     try:
@@ -237,5 +281,5 @@ def handle_exception(e):
 
 
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", 8000)) 
+    port = int(os.getenv("PORT", 8000))
     app.run(host="0.0.0.0", port=port, debug=os.getenv("FLASK_ENV") != "production")
\ No newline at end of file
diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index d2d25e9c..7528ce4f 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -56,6 +56,7 @@ export class FlaskBackend implements Backend {
 	};
 	private pendingRequests = new Map<string, PendingRequest>();
 	private messageId = 0;
+	private isInitializing = false
 
 	// Output callbacks
 	private stdoutCallback: ((value: string) => void) | null = null;
@@ -68,13 +69,34 @@ export class FlaskBackend implements Backend {
 	async init(): Promise<void> {
 		const state = this.getState();
 		if (state.initialized || state.loading) return;
+		
+		let id = this.generateId()
 
-		this.handleResponse({
-			type: "stdout",
-			value: "Your backend preference has been set to a Flask web server, initialization has already occured",
-		});
+		this.isInitializing = true
+
+		let data:any = await fetch(getFlaskBackendUrl()+"/initialize").then(res => res.json())
 
-		this.handleResponse({ type: "ready" });
+		if(data.success) {
+			this.handleResponse({
+				type: "stdout",
+				value: "Your backend preference has been set to a Flask web server, initialization has already occured",
+			});
+
+			this.handleResponse({ type: "ready" });
+		} else {
+			let error = data.error
+			this.handleError({
+				type: "error",
+				error: error
+			})
+			this.isInitializing = false
+			backendState.update((s) => ({
+				...s,
+				loading: false,
+				error: error instanceof Error ? error.message : String(error)
+			}));
+			throw error;
+		}
 	}
 
 	terminate(): void {}
@@ -327,6 +349,7 @@ export class FlaskBackend implements Backend {
 					});
 
 					for (let dataChunk of dataChunks) {
+						console.log("Streaming data: ", dataChunk.result)
 						this.handleResponse({
 							type: "stream-data",
 							id,
@@ -415,6 +438,7 @@ export class FlaskBackend implements Backend {
 					loading: false,
 					progress: STATUS_MESSAGES.READY,
 				}));
+				this.isInitializing = false
 				break;
 
 			case "progress":
diff --git a/src/lib/utils/flaskRoutes.ts b/src/lib/utils/flaskRoutes.ts
index e05f09d3..656ef6c6 100644
--- a/src/lib/utils/flaskRoutes.ts
+++ b/src/lib/utils/flaskRoutes.ts
@@ -1,4 +1,4 @@
-// import process from "process"
+
 
 export function getFlaskBackendUrl() {
     // Right now it is this local address, but when we set up the server I'll make it that permanent address

From 86f0d77bb35dabcc8aa2dc7e8886a289855210dc Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 30 Jan 2026 10:56:31 -0500
Subject: [PATCH 37/39] Beginning to work on THE meta-namespace (reverting back
 changes)

---
 src/backend.py                            | 98 +++++++++++------------
 src/lib/pyodide/backend/flask/backend.ts  |  4 +-
 src/lib/pyodide/backend/pyodide/worker.ts |  2 +
 src/lib/pyodide/backend/registry.ts       |  1 +
 4 files changed, 55 insertions(+), 50 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 4a5393d6..5446d77f 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -4,15 +4,20 @@
 import requests as req
 from flask import Flask, request, jsonify, Response, stream_with_context, session
 from flask_cors import CORS
+from flask_session import Session
+from cachelib import FileSystemCache
+
 from dotenv import load_dotenv
-import argparse
-from types import SimpleNamespace
+import pickle
+import types
+import uuid
 
 import io
 from contextlib import redirect_stdout, redirect_stderr
 
 # Initialization Code
 
+import ast
 import numpy as np
 import gc
 import pathsim, pathsim_chem
@@ -31,8 +36,19 @@
 
 load_dotenv()
 
+server_namespace = {}
+
 app = Flask(__name__, static_folder="../static", static_url_path="")
-app.secret_key = os.getenv("SECRET_KEY")
+
+print("The secret key is: ", os.getenv("SECRET_KEY"))
+
+SECRET_KEY = os.getenv("SECRET_KEY")
+SESSION_TYPE = 'cachelib'
+SESSION_SERIALIZATION_FORMAT = 'json'
+SESSION_CACHELIB = FileSystemCache(threshold=500, cache_dir="/sessions")
+app.config.from_object(__name__)
+
+Session(app)
 
 if os.getenv("FLASK_ENV") == "production":
     CORS(app,
@@ -56,13 +72,24 @@
     )
 
 @app.route("/initialize", methods=["GET"])
-def intialize():
-    # The purpose of initialization in Flask is s8imply just to clear the current namespace!
+def initalize():
+    session_id = "None provided...."
+
+    if "id" in session:
+        app.logger.info("Our current session ID is %s", session["id"])
+        session_id = session["id"]
+    else:
+        app.logger.info("Making a session id...")
+        session_id = uuid.uuid4()
+        session["id"] = session_id
+        session.permanent = True
+        app.logger.info("Made the id: ", session_id)
+
     try:
-        session["namespace"] = json.dumps({})
-        print("Successfully reset session namespace")
+
         return jsonify({
-            "success": True
+            "success": True,
+            "id": session_id
         })
     except Exception as e:
         return jsonify({
@@ -70,9 +97,13 @@ def intialize():
             "error": e
         }), 400
 
-@app.route("/namespaceCheck", methods=["GET"])
+@app.route("/idCheck", methods=["GET"])
 def namespaceCheck():
-    return jsonify({"namespace": session["namespace"]})
+    session_id = "No ID provided"
+    if "id" in session:
+        session_id = session["id"]
+
+    return jsonify({ "success": True, "id": session_id })
 
 # Execute Python route copied from the previous repository
 @app.route("/execute-code", methods=["POST"])
@@ -86,43 +117,27 @@ def execute_code():
         if not code.strip():
             return jsonify({"success": False, "error": "No code provided"}), 400
 
-        # Create a temporary namespace that includes current eval_namespace
-        temp_namespace = {}
-        if "namespace" in session:
-            app.logger.info("We have a temporary namespace in session...")
-            temp_namespace = session["namespace"]
-        else:
-            app.logger.info("We are instantiating an empty namespace...")
-            temp_namespace = {}
-        # temp_namespace.update(globals())
-
         # Capture stdout and stderr
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
 
+        temp_namespace = {}
+
         try:
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                exec(code, globals=globals(), locals= temp_namespace)
-            
-            app.logger.info(type(temp_namespace))
-            app.logger.info(temp_namespace)
-            app.logger.info("Stringified Dictionary: ", str(temp_namespace))
-            # app.logger.info("Temporary Namespace:")
-            # app.logger.info(json.dumps(temp_namespace))
-            # jsonString = json.dumps(temp_namespace)
-            session["namespace"] = repr(temp_namespace)
-            # app.logger.info("What we return is: ", jsonString)
+                exec(code, server_namespace)
+
             # Capture any output
             output = stdout_capture.getvalue()
             error_output = stderr_capture.getvalue()
 
             if error_output:
                 return jsonify({"success": False, "error": error_output})
-            
+
             return jsonify(
                 {
                     "success": True,
-                    "output": output
+                    "output": output,
                 }
             )
 
@@ -146,20 +161,13 @@ def evaluate_expression():
         
         temp_namespace = {}
 
-        if "namespace" in session:
-            temp_namespace = session["namespace"]
-        else:
-            temp_namespace = {}
-
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
 
         try:
             result = ""
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                result = eval(expr, temp_namespace)
-
-            session["namespace"] = json.dumps(SimpleNamespace(temp_namespace))
+                result = eval(expr, server_namespace)
 
             # Capture any output
             output = stdout_capture.getvalue()
@@ -196,12 +204,6 @@ def check_traceback():
 def stream_data():
     def generate(expr):
 
-        temp_namespace = {}
-        if "namespace" in session:
-            temp_namespace = session["namespace"]
-        else:
-            temp_namespace = {}
-
         # Capture stdout and stderror
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
@@ -212,9 +214,7 @@ def generate(expr):
 
             result = " "
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                result = eval(expr, temp_namespace)
-
-            session["namespace"] = json.dumps(SimpleNamespace(temp_namespace))
+                result = eval(expr, server_namespace)
 
             # Capture any output
             output = stdout_capture.getvalue()
diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 7528ce4f..3abfdee1 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -531,10 +531,12 @@ export class FlaskBackend implements Backend {
 							headers: {
 								"Content-Type": "application/json",
 							},
-							body: JSON.stringify({ code: code }),
+							body: JSON.stringify({ namespace: localStorage.getItem("namespace"), code: code }),
 						},
 					).then((res) => res.json());
 					if (data.success && !data.error) {
+						localStorage.setItem("namespace", data.namespace)
+						console.log("The data given from /execute-code", data)
 						if (data.output) {
 							this.handleResponse({
 								type: "stdout",
diff --git a/src/lib/pyodide/backend/pyodide/worker.ts b/src/lib/pyodide/backend/pyodide/worker.ts
index 0e3ed79a..f52ac356 100644
--- a/src/lib/pyodide/backend/pyodide/worker.ts
+++ b/src/lib/pyodide/backend/pyodide/worker.ts
@@ -91,6 +91,8 @@ print(f"${pkg.import} {${pkg.import}.__version__} loaded successfully")
 
     // Capture clean state for later cleanup
     await pyodide.runPythonAsync(`_clean_globals = set(globals().keys())`);
+    console.log("Pyodide Globals are: ", pyodide.globals)
+    console.log("Trying to access numpy, ", pyodide.globals.get("numpy"))
 
     isInitialized = true;
     send({ type: "ready" });
diff --git a/src/lib/pyodide/backend/registry.ts b/src/lib/pyodide/backend/registry.ts
index 4c68cf06..b8f80fcb 100644
--- a/src/lib/pyodide/backend/registry.ts
+++ b/src/lib/pyodide/backend/registry.ts
@@ -18,6 +18,7 @@ let currentBackendType: BackendPreference | null = null;
  * Get the current backend, creating a Pyodide backend if none exists
  */
 export function getBackend(): Backend {
+	
 	let currentBackendPreference = backendPreferenceStore.get()
 	if (!currentBackend) {
 		if(currentBackendPreference == null) currentBackendPreference = "pyodide"

From 04f5014f73f16952ecf20d832145be72b28d77ab Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 30 Jan 2026 13:36:14 -0500
Subject: [PATCH 38/39] Added individual namespaces

---
 src/backend.py                           | 96 ++++++++++++++++++------
 src/lib/pyodide/backend/flask/backend.ts | 15 +++-
 2 files changed, 84 insertions(+), 27 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index 5446d77f..a5726868 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -3,8 +3,9 @@
 import traceback
 import requests as req
 from flask import Flask, request, jsonify, Response, stream_with_context, session
-from flask_cors import CORS
 from flask_session import Session
+from flask_cors import CORS
+
 from cachelib import FileSystemCache
 
 from dotenv import load_dotenv
@@ -36,19 +37,25 @@
 
 load_dotenv()
 
-server_namespace = {}
+server_namespaces = {}
 
 app = Flask(__name__, static_folder="../static", static_url_path="")
 
-print("The secret key is: ", os.getenv("SECRET_KEY"))
+# app.secret_key = os.getenv("SECRET_KEY")
+# app.config["SECRET_KEY"] = os.getenv("SECRET_KEY")
 
-SECRET_KEY = os.getenv("SECRET_KEY")
-SESSION_TYPE = 'cachelib'
-SESSION_SERIALIZATION_FORMAT = 'json'
-SESSION_CACHELIB = FileSystemCache(threshold=500, cache_dir="/sessions")
-app.config.from_object(__name__)
+# app.config["SESSION_PERMANENT"] = False
+# app.config["SESSION_TYPE"] = 'filesystem'
+app.config.update(
+    SECRET_KEY=os.getenv("SECRET_KEY"), # Required for session
+    SESSION_COOKIE_SAMESITE='None',
+    SESSION_COOKIE_SECURE=True,
+    SESSION_COOKIE_HTTPONLY=True,
+)
+# app.config["SESSION_SERIALIZATION_FORMAT"] = 'json'
+# app.config["SESSION_CACHELIB"] = FileSystemCache(threshold=500, cache_dir="/sessions"),
 
-Session(app)
+# Session(app)
 
 if os.getenv("FLASK_ENV") == "production":
     CORS(app,
@@ -57,8 +64,8 @@
                  "origins": ["*"],
                  "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
                  "allow_headers": ["Content-Type", "Authorization"]
-             } 
-         })
+             }
+         }, supports_credentials=True)
 else:
     print("We are not in production...")
     CORS(
@@ -73,17 +80,20 @@
 
 @app.route("/initialize", methods=["GET"])
 def initalize():
-    session_id = "None provided...."
+    session_id = None
 
     if "id" in session:
-        app.logger.info("Our current session ID is %s", session["id"])
         session_id = session["id"]
+        app.logger.info("We already have a session ID it is...")
+        app.logger.info(session_id)
     else:
         app.logger.info("Making a session id...")
-        session_id = uuid.uuid4()
+        session_id = str(os.urandom(12))
+        app.logger.info("Made the id: ")
+        app.logger.info(session_id)
         session["id"] = session_id
-        session.permanent = True
-        app.logger.info("Made the id: ", session_id)
+
+    server_namespaces[session_id] = {}
 
     try:
 
@@ -98,13 +108,29 @@ def initalize():
         }), 400
 
 @app.route("/idCheck", methods=["GET"])
-def namespaceCheck():
-    session_id = "No ID provided"
+def idCheck():
+    session_id = None
     if "id" in session:
         session_id = session["id"]
 
     return jsonify({ "success": True, "id": session_id })
 
+@app.route("/namespaceCheck", methods=["GET"])
+def namespaceCheck():
+    namespace = {}
+    session_id = None
+    if "id" in session:
+        app.logger.info("The id exists...")
+        session_id = session["id"]
+        if session_id in server_namespaces:
+            app.logger.info("Found an associated namespace...")
+            namespace = server_namespaces[session["id"]]
+    keys = ""
+    if isinstance(namespace, dict):
+        for k in server_namespaces.keys():
+            keys += k + ", "
+
+    return jsonify({ "success": True, "namespace_keys": keys})
 # Execute Python route copied from the previous repository
 @app.route("/execute-code", methods=["POST"])
 def execute_code():
@@ -121,11 +147,18 @@ def execute_code():
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
 
-        temp_namespace = {}
+        user_namespace = {}
+        app.logger.info("Session: ", session)
+        app.logger.info("Session ID: ", session["id"])
+        if "id" in session:
+            user_namespace = server_namespaces[session["id"]]
 
         try:
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                exec(code, server_namespace)
+                exec(code, user_namespace)
+
+            if "id" in session:
+                server_namespaces[session["id"]] = user_namespace
 
             # Capture any output
             output = stdout_capture.getvalue()
@@ -158,16 +191,21 @@ def evaluate_expression():
         
         if not expr.strip():
             return jsonify({"success": False, "error": "No Python expression provided"}), 400
-        
-        temp_namespace = {}
 
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
 
+        user_namespace = {}
+        if "id" in session:
+            user_namespace = server_namespaces[session["id"]]
+
         try:
             result = ""
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                result = eval(expr, server_namespace)
+                result = eval(expr, user_namespace)
+
+            if "id" in session:
+                server_namespaces[session["id"]] = user_namespace
 
             # Capture any output
             output = stdout_capture.getvalue()
@@ -208,13 +246,21 @@ def generate(expr):
         stdout_capture = io.StringIO()
         stderr_capture = io.StringIO()
 
+        user_namespace = {}
+        if "id" in session:
+            user_namespace = server_namespaces[session["id"]]
+
         isDone = False
         
         while not isDone:
 
             result = " "
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                result = eval(expr, server_namespace)
+                result = eval(expr, user_namespace)
+
+
+            if "id" in session:
+                server_namespaces[session["id"]] = user_namespace
 
             # Capture any output
             output = stdout_capture.getvalue()
@@ -282,4 +328,6 @@ def handle_exception(e):
 
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 8000))
+    print("Hello there...our port is: ", port)
+    print("Application Configuration: ", app.config)
     app.run(host="0.0.0.0", port=port, debug=os.getenv("FLASK_ENV") != "production")
\ No newline at end of file
diff --git a/src/lib/pyodide/backend/flask/backend.ts b/src/lib/pyodide/backend/flask/backend.ts
index 3abfdee1..b80bfdfb 100644
--- a/src/lib/pyodide/backend/flask/backend.ts
+++ b/src/lib/pyodide/backend/flask/backend.ts
@@ -74,7 +74,9 @@ export class FlaskBackend implements Backend {
 
 		this.isInitializing = true
 
-		let data:any = await fetch(getFlaskBackendUrl()+"/initialize").then(res => res.json())
+		let data:any = await fetch(getFlaskBackendUrl()+"/initialize", {
+			credentials: "include"
+		}).then(res => res.json())
 
 		if(data.success) {
 			this.handleResponse({
@@ -257,6 +259,7 @@ export class FlaskBackend implements Backend {
 					let data = await fetch(
 						getFlaskBackendUrl() + "/execute-code",
 						{
+							credentials: "include",
 							method: "POST",
 							headers: {
 								"Content-Type": "application/json",
@@ -282,7 +285,9 @@ export class FlaskBackend implements Backend {
 				}
 			}
 
-			let response = await fetch(getFlaskBackendUrl() + "/streamData");
+			let response = await fetch(getFlaskBackendUrl() + "/streamData", {
+				credentials: "include"
+			});
 
 			if (response.body) {
 				for await (const chunk of response.body) {
@@ -418,7 +423,9 @@ export class FlaskBackend implements Backend {
 
 		try {
 			traceback = (
-				await fetch(getFlaskBackendUrl() + "/traceback")
+				await fetch(getFlaskBackendUrl() + "/traceback", {
+					credentials: "include"
+				})
 					.then((res) => res.json())
 					.then((res) => res.json)
 			).traceback as string;
@@ -527,6 +534,7 @@ export class FlaskBackend implements Backend {
 					let data = await fetch(
 						getFlaskBackendUrl() + "/execute-code",
 						{
+							credentials: "include",
 							method: "POST",
 							headers: {
 								"Content-Type": "application/json",
@@ -559,6 +567,7 @@ export class FlaskBackend implements Backend {
 					let data = await fetch(
 						getFlaskBackendUrl() + "/evaluate-expression",
 						{
+							credentials: "include",
 							method: "POST",
 							headers: {
 								"Content-Type": "application/json",

From d82dee9b0c35a840fbdce2bb56023187812343ae Mon Sep 17 00:00:00 2001
From: King-Diorr Willsun <51097023+KDW1@users.noreply.github.com>
Date: Fri, 30 Jan 2026 14:24:17 -0500
Subject: [PATCH 39/39] Added the url parameter switch for the backend type

---
 src/backend.py                      |  9 +++++++--
 src/lib/pyodide/backend/registry.ts |  8 ++++----
 src/routes/+page.svelte             | 15 ++-------------
 3 files changed, 13 insertions(+), 19 deletions(-)

diff --git a/src/backend.py b/src/backend.py
index a5726868..acbbb617 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -55,7 +55,7 @@
 # app.config["SESSION_SERIALIZATION_FORMAT"] = 'json'
 # app.config["SESSION_CACHELIB"] = FileSystemCache(threshold=500, cache_dir="/sessions"),
 
-# Session(app)
+# Session(app)f
 
 if os.getenv("FLASK_ENV") == "production":
     CORS(app,
@@ -157,6 +157,8 @@ def execute_code():
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
                 exec(code, user_namespace)
 
+            app.logger.info("User Namespace: ", user_namespace)
+
             if "id" in session:
                 server_namespaces[session["id"]] = user_namespace
 
@@ -204,6 +206,8 @@ def evaluate_expression():
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
                 result = eval(expr, user_namespace)
 
+            app.logger.info("User Namespace: ", user_namespace)
+
             if "id" in session:
                 server_namespaces[session["id"]] = user_namespace
 
@@ -258,7 +262,8 @@ def generate(expr):
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
                 result = eval(expr, user_namespace)
 
-
+            app.logger.info("User Namespace: ", user_namespace)
+            
             if "id" in session:
                 server_namespaces[session["id"]] = user_namespace
 
diff --git a/src/lib/pyodide/backend/registry.ts b/src/lib/pyodide/backend/registry.ts
index b8f80fcb..9e40a26f 100644
--- a/src/lib/pyodide/backend/registry.ts
+++ b/src/lib/pyodide/backend/registry.ts
@@ -8,6 +8,7 @@ import { PyodideBackend } from './pyodide/backend';
 import type { BackendPreference } from '$lib/types';
 import { backendPreferenceStore } from '$lib/stores';
 import { FlaskBackend } from './flask/backend';
+import { page } from '$app/state';
 
 export type BackendType = 'pyodide' | 'local' | 'remote';
 
@@ -18,14 +19,13 @@ let currentBackendType: BackendPreference | null = null;
  * Get the current backend, creating a Pyodide backend if none exists
  */
 export function getBackend(): Backend {
-	
-	let currentBackendPreference = backendPreferenceStore.get()
+	let currentBackendPreference = page.url.searchParams.get('backend') ?? "pyodide"
 	if (!currentBackend) {
 		if(currentBackendPreference == null) currentBackendPreference = "pyodide"
-		currentBackend = createBackend(currentBackendPreference);
+		currentBackend = createBackend(currentBackendPreference as BackendPreference);
 	}
 	if(getBackendType() !== currentBackendPreference) {
-		switchBackend(currentBackendPreference)
+		switchBackend(currentBackendPreference as BackendPreference)
 	}
 	return currentBackend;
 }
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 9cada15a..665531c1 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -68,6 +68,7 @@
 	// --------------------------- ROOT PAGE IMPORTS | END ---------------------------
 
 	import { isInputFocused } from '$lib/utils/focus';
+	import { page } from '$app/state';
 	
 	// Track mouse position for paste operations
 	let mousePosition = $state({ x: 0, y: 0 });
@@ -403,7 +404,7 @@
 	let hasRunSimulation = $state(false);
 	let statusText = $state('Ready');
 	let currentTheme = $state<Theme>('dark');
-	let currentBackendPreference = $state<BackendPreference>('pyodide');
+	let currentBackendPreference = $state<BackendPreference>(page.url.searchParams.get("backend") as BackendPreference ?? "pyodide");
 	let consoleLogCount = $state(0);
 	let plotActiveTab = $state(0);
 	let plotViewMode = $state<'tabs' | 'tiles'>('tabs');
@@ -710,10 +711,6 @@
 					event.preventDefault();
 					themeStore.toggle();
 					return;
-				case 'q':
-					event.preventDefault();
-					backendPreferenceStore.toggle();
-					return;
 				case '+':
 				case '=':
 					if (!event.ctrlKey && !event.metaKey) {
@@ -1172,14 +1169,6 @@
 			>
 				<Icon name="terminal" size={18} />
 			</button>
-			<button
-				class="toggle-btn"
-				onclick={() => backendPreferenceStore.toggle()}
-				use:tooltip={{ text: currentBackendPreference === 'pyodide' ? 'You are using Pyodide Web Assembly' : 'You are using a Flask Web Server', shortcut: "Q", position: "right" }}
-				aria-label="Toggle your backend preference"
-			>
-				<Icon name={currentBackendPreference === 'pyodide' ? 'laptop' : 'server'} size={18} />
-			</button>
 		</div>
 
 		<!-- Simulation settings -->