Merge pull request #15 from pnnl/electron-upgrade

Electron upgrade

Author: itsMando

.gitignore

@@ -34,3 +34,7 @@ Dockerfile
 *.njsproj
 *.sln
 *.sw?
+
+# Electron / PyInstaller build outputs (build/ at repo root holds icons and IS tracked)
+release/
+local-server/build/

Dockerfile.backend

@@ -13,12 +13,35 @@ RUN apt-get update \
 
 # Install server deps (no pyinstaller). --prerelease=allow: cim-graph is 0.4.3a10.
 COPY local-server/requirements-server.txt ./requirements-server.txt
-RUN uv pip install --system --prerelease=allow -r requirements-server.txt \
-    && uv pip install --system glm
+RUN uv pip install --system --prerelease=allow -r requirements-server.txt
 
-# CIM-Builder — installed without deps (it requires an older cim-graph).
-RUN git clone -b develop https://github.com/PNNL-CIM-Tools/CIM-Builder.git /tmp/CIM-Builder \
-    && uv pip install --system --no-deps /tmp/CIM-Builder
+# ---- Nim toolchain: build the glm parser into a Python wheel ----------------
+# glm (https://github.com/itsMando/glm) is a Nim project that exposes a Python
+# binary extension (lib/_glm.so). It needs Nim >= 2.0, a C compiler, and
+# choosenim to fetch the toolchain (Debian's packaged Nim is too old).
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends build-essential curl xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV CHOOSENIM_NO_ANALYTICS=1
+RUN curl -sSf https://nim-lang.org/choosenim/init.sh | sh -s -- -y
+ENV PATH="/root/.nimble/bin:${PATH}"
+
+# setup.py builds the binary (non-pure) wheel; these are its build-backend deps.
+RUN uv pip install --system setuptools wheel
+
+# Clone the glm fork and build the Nim shared library (lib/_glm.so), then install
+# straight from source into the system site-packages. setup.py copies the freshly
+# built _glm.so into the package and tags the wheel for whatever platform we are
+# building on, so this stays arch-agnostic (x86_64, arm64, ...) — unlike `nimble
+# package`, which hard-codes a manylinux2014_x86_64 tag. The install carries over
+# to the runtime stage via the /usr/local copy below.
+RUN git clone https://github.com/itsMando/glm.git /tmp/glm \
+    && cd /tmp/glm \
+    && nimble install -y --depsOnly \
+    && nimble release \
+    && uv pip install --system --no-build-isolation /tmp/glm \
+    && rm -rf /tmp/glm
 
 # ---- runtime: slim image with only the installed packages + app ------------
 FROM python:3.12-slim

README.md

@@ -68,7 +68,7 @@ cd GLIMPSE/local-server/
 **Option A: UV (Recommended)**
 
 ```bash
-uv add -r requirements.txt --prerelease=allow
+uv sync
 ```
 
 **Option B: VENV**
@@ -108,35 +108,7 @@ If you used VENV or Conda, install requirements:
 pip install -r requirements.txt
 ```
 
-### Step 4: Install CIM-Builder (Required)
-
-CIM-Builder is needed to export modified CIM/XML files.
-
-In `GLIMPSE/local-server/`, clone CIM-Builder:
-
-```bash
-git clone -b develop https://github.com/PNNL-CIM-Tools/CIM-Builder.git
-```
-
-Navigate to the CIM-Builder directory and install it (without dependencies, as it requires an older version of cim-graph):
-
-```bash
-cd CIM-Builder
-```
-
-**With PIP:**
-
-```bash
-python -m pip install . --no-deps
-```
-
-**With UV:**
-
-```bash
-uv pip install . --no-deps
-```
-
-### Step 5: Install GLM Parser
+### Step 4: Install GLM Parser
 
 #### Standard Installation (Windows, Linux, Intel/AMD Mac)
 
@@ -156,14 +128,14 @@ uv pip install glm
 
 You'll need to build the GLM parser from source using Nim.
 
-Clone the GLM parser:
+Clone the glm parser repository i forked:
 
 ```bash
 cd GLIMPSE/local-server/
 ```
 
 ```bash
-git clone https://github.com/NREL/glm.git
+git cone https://github.com/itsMando/glm.git
 ```
 
 ```bash
@@ -173,29 +145,26 @@ cd glm
 Build the parser (ensure [Nim](https://nim-lang.org/) is installed and in your PATH):
 
 ```bash
-nim c -d:release --opt:size --passC:"-flto" --passL:"-flto" --app:lib --out:lib/_glm.so src/glm.nim
+nimble -v
 ```
 
-Create a wheel:
-
 ```bash
-python setup.py bdist_wheel
-# or
-python3 setup.py bdist_wheel
+nimble package
+nimble release
 ```
 
-Install the wheel from `dist/` folder:
+Install the python binary distributable from `dist/` folder:
 
 **With PIP:**
 
 ```bash
-pip install dist/<whl-filename>.whl
+pip install dist/*.whl
 ```
 
 **With UV:**
 
 ```bash
-uv pip install dist/<whl-filename>.whl
+uv pip install dist/*.whl
 ```
 
 ## Start GLIMPSE
@@ -208,6 +177,43 @@ npm run dev
 
 The application will start in development mode. Open your browser and navigate to the provided local address (typically `http://localhost:5173/`) to access GLIMPSE.
 
+## Desktop App (Electron)
+
+GLIMPSE can also run as a standalone desktop application. The Electron shell starts the bundled local server automatically on launch and shuts it down (including all child processes) when the window is closed — no terminal or browser needed.
+
+> [!NOTE]
+> These steps assume you have completed the **Build from Source** setup above (Node dependencies and the Python environment for `local-server/`). The Python environment must include `pyinstaller`, which is listed in both `local-server/requirements.txt` and `local-server/pyproject.toml`.
+
+### Develop in a Desktop Window
+
+Runs the Python backend, the Vite dev server, and Electron together (with hot reload). Closing the Electron window stops all three:
+
+```bash
+npm run electron:dev
+```
+
+### Build an Installer
+
+Installers are built **on and for the OS you are running** (electron-builder cannot cross-compile, e.g. a Windows installer must be built on Windows):
+
+```bash
+npm run dist          # build for the current OS
+npm run dist:linux    # AppImage + .deb   (run on Linux)
+npm run dist:win      # NSIS installer    (run on Windows)
+npm run dist:mac      # .dmg              (run on macOS)
+```
+
+Each `dist` command runs three steps:
+
+1. `vite build` — bundles the React frontend into `dist/`
+2. `pyinstaller server.spec` — freezes the Python backend (with its Python runtime) into `local-server/dist/server/`
+3. `electron-builder` — packages both into an installer in `release/`
+
+The finished installer is written to the `release/` directory. The installed app needs no Node or Python on the target machine — the backend is fully self-contained.
+
+> [!TIP]
+> If `pyinstaller` is not on your PATH, activate the Python environment you created for `local-server/` first (or, with UV, run `uv run pyinstaller server.spec --noconfirm` inside `local-server/`).
+
 ## Run with Docker
 
 The repository ships with a [Docker Compose](https://docs.docker.com/compose/) setup that builds and runs GLIMPSE as two containers — the React frontend (served by nginx) and the Flask + SocketIO backend — so you don't need to install Node, Python, or any of the plugins yourself.

build/icon.png

@@ -0,0 +1,52 @@
+# electron-builder configuration for GLIMPSE desktop installers.
+#
+# Build the renderer (vite build) and the backend (pyinstaller) first —
+# the `dist`/`dist:*` npm scripts chain all three steps.
+#
+# Installers can only be built on (or for) the OS you are running on:
+#   npm run dist:linux  -> AppImage + .deb   (build on Linux)
+#   npm run dist:win    -> NSIS installer    (build on Windows)
+#   npm run dist:mac    -> .dmg              (build on macOS)
+
+appId: gov.pnnl.glimpse
+productName: GLIMPSE
+copyright: Copyright © 2026 Pacific Northwest National Laboratory
+
+directories:
+  output: release
+  buildResources: build
+
+# The frontend is fully bundled by Vite, so node_modules are not needed at runtime.
+files:
+  - dist/**
+  - electron/**
+  - package.json
+  - "!node_modules/**"
+
+# PyInstaller onedir output for the Flask/SocketIO backend. Packaged into
+# <app>/resources/server/ and spawned by electron/main.js on startup.
+extraResources:
+  - from: local-server/dist/server
+    to: server
+
+asar: true
+
+win:
+  target:
+    - nsis
+
+nsis:
+  oneClick: false
+  allowToChangeInstallationDirectory: true
+
+mac:
+  target:
+    - dmg
+  category: public.app-category.utilities
+
+linux:
+  target:
+    - AppImage
+    - deb
+  category: Science
+  synopsis: Power grid model visualization tool