quantui 0.8.2__tar.gz → 0.10.0__tar.gz

{quantui-0.8.2 → quantui-0.10.0}/CHANGELOG.md

@@ -7,6 +7,251 @@ and this project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.ht
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-10-03
+
+### Added
+
+- **Upload structure files** — new **Upload File** tab (Calculate → Molecule
+  Input) and **Load as molecule** on the Files tab: XYZ (last frame), MOL,
+  SDF, MOL2, PDB, CIF, Gaussian `.gjf`/`.com` and `.log`/`.out`. Charge and
+  multiplicity are read from the file when it records them; 2-D MOL/SDF
+  drawings are embedded in 3-D.
+- **Download to your computer** — every export (structure files, script,
+  bundle, cubes, PNGs, plots, CSV, animations) now offers a browser download
+  link, and the Files tab has a **Download** button. Works on remote
+  Voilà/OnDemand sessions; files over 25 MB get a notice instead.
+- **Implicit solvent for optimizations, frequencies and TD-DFT** — Geometry
+  Opt is solvated at every step; Frequency uses PySCF's PCM Hessian and
+  solvated IR displacements (Raman is skipped in solvent); TD-DFT uses an
+  equilibrium ground state and non-equilibrium excitations with each
+  solvent's own optical dielectric. Also in SLURM batch jobs.
+- **Point groups and orbital symmetry labels** — the molecule summary and
+  result cards show the point group (0.01 Å tolerance, with a "nearly X"
+  hint); the orbital energy diagram labels orbitals textbook-style
+  (1a₁, 2a₁, 1b₂, 3a₁, 1b₁ for water; σ/π for linear molecules; C₃ᵥ labels
+  for NH₃).
+- **Density, spin-density and ESP surfaces** — the Isosurface panel draws the
+  electron density, the spin density (α − β) and the electrostatic potential
+  mapped on the density surface (red = negative, blue = positive, with a
+  colour bar), and α/β orbitals for unrestricted results.
+- **Vibration viewer** — displacement arrows, an amplitude slider and a table
+  of every mode with IR intensity and Raman activity.
+- **Thermochemistry at any temperature and pressure** — recomputed from the
+  stored frequencies (no new calculation), with U, H, S, G, Cv, Cp and the
+  rotational symmetry number.
+- **Edit Structure** — set a bond length, angle or dihedral to a value,
+  delete atoms, add a hydrogen, change an element, undo; pick atoms by
+  clicking the viewer. **Freeze atoms** for a constrained Geometry Opt.
+- **Orbital gallery** — the Isosurface panel's **Orbital gallery** button
+  shows the orbitals around the HOMO–LUMO gap (2, 3 or 4 on each side) as
+  small viewers that rotate together, each labelled with its symmetry and
+  energy; follows the α/β choice for unrestricted results.
+- **Transition State calc type** — searches for the saddle point near the
+  input geometry with Sella (starting from the analytic Hessian, with the
+  same PySCF settings as an optimization: PCM, density fitting, D3, GPU, SCF
+  rescue), then runs a frequency calculation and says plainly whether it
+  found a transition state (exactly one imaginary frequency), a minimum, or
+  a higher-order saddle point. Results open on the Vibrational panel to
+  animate the imaginary mode, plus IR, search trajectory, orbitals and
+  populations. Needs the optional extra: `pip install "quantui[ts]"`.
+  Local runs only for now (not SLURM batch).
+- **Populations and Isosurface for Frequency and TD-DFT results** — both
+  record the reference SCF's Mulliken charges, dipole and orbitals (both spin
+  channels for UHF/UKS), so the Populations, Isosurface and (TD-DFT) Energies
+  panels fill for them too, locally and from SLURM. Frequency Molden files
+  now include the orbitals.
+- **⟨S²⟩ for open-shell results** — single points record and show ⟨S²⟩
+  next to the ideal S(S+1), flagged when off by more than 10 % (spin
+  contamination). Reorganization-energy results record it at all four
+  points of each channel (`s2_*` fields in `result.json`), so a
+  spin-contaminated ion SCF can be filtered out of a λ dataset.
+- **Submit from a login node with `quantui-batch`** — a standard-library
+  Python 3.6+ launcher for SSH users. It never starts the image or imports
+  QuantUI on the login node: it writes the same job folder as
+  `SlurmBackend.prepare()` (constants copied from QuantUI at install time,
+  logic held equal by tests) and calls `sbatch`; the calculation runs in the
+  image on a compute node. Install once per image, e.g.
+  `apptainer exec IMAGE quantui install-launcher /shared/bin`.
+  `quantui-batch submit mol.xyz --calc frequency --method B3LYP --basis def2-SVP`;
+  `status`, `log`, `rerun` (e.g. `--mem=64G` after running out of memory),
+  `cancel`, `estimate` and `path` follow it. At most
+  `QUANTUI_MAX_CONCURRENT_JOBS` (default 2) QuantUI jobs may be queued or
+  running per user, counted from the real queue.
+- **`quantui-batch` workflow commands** — `--preset NAME` (shared
+  `presets.json` beside the launcher, plus per-user presets); `--from JOB`
+  starts from another job's optimized geometry, waiting on it with an
+  `afterok` dependency if it is still running (the worker loads the geometry
+  at run time, `quantui/backends/batch_chain.py`); `--queue-rest` lines jobs
+  up behind the user's running ones instead of refusing them; a duplicate
+  guard (`--again` to override); `rerun --more-memory` / `--more-time`;
+  `results JOB` (energy, convergence, imaginary modes, strongest IR bands,
+  excited states, shifts); `presets`; and `check` (python, image, Slurm
+  commands, job folders and free space, presets).
+- **Every QuantUI batch job is tagged `#SBATCH --comment=quantui`**, so an
+  operator can list all of them with `squeue -o "%k"`.
+- **`quantui submit` accepts `.xyz` files** with `--calc`, `--method`,
+  `--basis`, `--charge`, `--mult`, `--solvent`, `--preopt` and repeatable
+  `--option KEY=VALUE`; an impossible charge/multiplicity is refused before
+  anything is queued. The same flags override a request JSON's values.
+- **`quantui submit --prepare-only`** writes the job folder (`request.json` +
+  `submit.slurm`) without calling `sbatch` and prints the script path. Its
+  registry record has the new non-active status `prepared`.
+
+### Changed
+
+- **The GPU image builds from the working tree, like the CPU image** —
+  `quantui-gpu.def` copies the same `%files` allowlist as `quantui.def` and
+  installs it editable, instead of a pinned PyPI release, so a GPU node runs
+  the code that was just tested. `build-gpu.sh` records the commit
+  (`git describe`) in the image's `QuantUICommit` label and
+  `/opt/build-info/quantui-commit.txt`; its `--version` flag is gone — check
+  out a release tag to build that release.
+- **Finished batch attempts reach History when the app starts**, even where
+  SLURM is unavailable (e.g. an OnDemand session), so jobs submitted from a
+  terminal show up without opening the Cluster Jobs tab.
+
+### Fixed
+
+- **PBE-D3 now includes D3** — it needed `pyscf.dftd3`, which no QuantUI
+  environment installed, so PBE-D3 ran as plain PBE (with a warning). D3
+  (zero damping) is now applied through PySCF's built-in dispersion
+  (`pyscf-dispersion`, added to the `[pyscf]` extra, the conda environment
+  and the CPU image), including in gradients and Hessians.
+- **Rotational symmetry number** — thermochemistry detected symmetry at
+  PySCF's strict tolerance, so slightly unsymmetric geometries (any
+  optimized water or ammonia) used σ = 1, overstating the entropy by R ln σ.
+  Symmetric molecules' S and G change.
+- **`quantui submit --depends-on`** accepts a request id or a SLURM job id
+  and resolves it; it used to write the request id into
+  `--dependency=afterok:` and validate nothing.
+- **"Geometry optimization before the calculation" on SLURM** — Single
+  Point and NMR batch jobs ignored the checkbox (the local run honoured it).
+- **Mode-displaced Frequency seeds are re-optimized** — picking "displace
+  along mode" as the Frequency seed disabled the pre-optimization, so the
+  frequencies were computed at a geometry that is not a stationary point.
+  The checkbox is now ticked for that seed (left on, user can untick).
+- **Reorganization Energy shows its optimizer settings** — the run used the
+  max-force and max-steps fields while they were hidden, so values left over
+  from Geometry Opt or PES Scan applied unseen.
+- **No placeholder Raman spectrum** — when Raman activities were not
+  computed (PCM run, or `pyscf-properties` missing), the Raman panel drew
+  every mode at the same height. It now says why there is no spectrum.
+- **Disconnected structures are flagged for every source** — the molecule
+  summary notes separate fragments for pasted, library, uploaded, edited and
+  History structures, not only Online Search results.
+- **Pasting a multi-frame XYZ** says what it is and how to load it, instead
+  of "Line N: not enough values".
+- **Export Script follows the calculation** — it used to write a gas-phase
+  single point whatever was set up. It now applies the selected PCM solvent
+  and density fitting, adds the Hessian + thermochemistry for Frequency and
+  the excited states (with the solvent's optical dielectric) for TD-DFT, and
+  says plainly when it covers only the SCF (Geometry Opt, NMR, PES Scan,
+  Reorganization Energy).
+- **CPU image: NMR and analytical Raman** — the image installed QuantUI
+  without the `[pyscf]` extra, so `pyscf-properties` was missing. It now
+  installs the extra, and the build fails if `pyscf.prop.nmr` or
+  `pyscf.dispersion` cannot be imported.
+- **Solvent names are case-insensitive**; an unknown solvent is an error.
+  A request with `"water"` used to run in the gas phase.
+- **Export Script** writes into the result folder instead of the server's
+  working directory.
+
+- **Solvated batch requests the worker cannot run are refused up front** —
+  `quantui submit` and `quantui-batch` reject an unknown solvent, and a
+  solvent on a calc type the batch worker runs gas-phase only (e.g. `nmr`),
+  instead of letting the job queue and then fail. The supported set now
+  lives in one place (`batch_input.SOLVENT_CALC_TYPES`).
+- **SLURM memory estimate for transition-metal complexes** —
+  `estimate_slurm_resources()` used a short element table without Mn, Co,
+  Ni, Mo and most other metals, so a metal counted as 0 electrons and the
+  memory estimate came out low. It now uses the full table.
+
+## [0.9.0] - 2026-09-26
+
+### Added
+
+- **SLURM job folders with per-attempt subfolders (M-JOBDIRS)** — each cluster
+  job gets a readable folder (`<formula>_<calc>_<method>_<basis>`, or the
+  optional **Job name** on the Calculate tab) that doubles as the SLURM job
+  name. Every run of its `submit.slurm` creates a new `attempt-NN_job<id>/`
+  subfolder, so **Resubmit** (new, Cluster Jobs tab) and a hand-run
+  `sbatch submit.slurm` never overwrite an earlier attempt. The job root is
+  configurable in **System Settings** (or `QUANTUI_STAGING_DIR`), for
+  clusters with small home quotas.
+- **SLURM results marked in History** — entries show
+  `🖥 SLURM <job id>·a<attempt>` and the result card has a "Ran on" row with
+  the job folder. Hand-run attempts are added to History on the next Cluster
+  Jobs refresh; failed attempts stay in the job folder only.
+- **GPU offload for geometry optimization** — gpu4pyscf offload now reaches
+  every SCF/gradient step of a geometry optimization, not just single points.
+  A separate, guarded CuPy GPU path for PyFock, GPU provenance
+  (`gpu_used` / `gpu_name`) on optimization results, and
+  `quantui gpu check --engine pyfock`.
+- **PyFock backend (M-PYFOCK)** — Phase 1: normalized engine dispatch,
+  native-Windows PBE/def2 single points for neutral closed-shell molecules,
+  capability-driven calculation menus, engine provenance in logs and saved
+  results, a pinned `pyfock` install extra, and a Windows water parity gate
+  against PySCF; unsupported hybrids, ions, open-shell systems, solvent,
+  checkpoints and orbital analysis are rejected before compute. Phase 2:
+  geometry optimization via PyFock's ASE calculator with analytical
+  density-fitted gradients; results keep orbital arrays, Mulliken charges,
+  dipoles, and engine-native cube generation.
+- **`quantui submit` CLI** — submit request JSON files to SLURM from a script
+  (with `--job-name`, `--dry-run`, resource and mail options); resource
+  estimates account for parallel IR/Raman workers.
+- **Checkpoint/resume for batch and Frequency runs** — the SLURM batch worker
+  resumes Geometry Optimization, PES Scan and Frequency runs from their
+  checkpoints; Frequency (interactive and batch) banks each finished
+  displacement so a restart skips completed ones.
+- **SCF rescue for hard open-shell cases (M-SCF-ROBUST)** — one shared
+  convergence-rescue helper at every SCF call site, with provenance lines in
+  the log.
+- **RKS/UKS/RHF/UHF label** on every result card, live and saved.
+
+### Changed
+
+- **SLURM output layout** — new submissions use the job-folder layout above
+  instead of `~/.quantui/staging/<request_id>/`. Jobs submitted earlier keep
+  their old folders and still list, reconnect and ingest.
+- **Unconverged results are no longer reported as converged** — CCSD/CCSD(T)
+  amplitudes, TD-DFT roots, frequency Hessians, and optimizer gradients from an
+  unconverged SCF are now flagged instead of shown as a clean result. Saved
+  cards name the step that failed rather than blaming the SCF.
+- **Parallel IR/Raman worker pools** are sized from the SLURM/cgroup
+  allocation, not the node's full CPU count.
+
+### Fixed
+
+- **Thermochemistry** — entropy units no longer corrupt the Gibbs free energy;
+  thermochemistry is saved and shown again when a frequency result is
+  reopened from History.
+- **Raman activities** — added the missing a₀³→ų polarizability conversion.
+- **Functionals** — ωB97X-D resolves to the real functional (not `wb97x`+D3),
+  and the D3 dispersion status is shown instead of silently dropped.
+- **ECP systems** — ECPs are passed to parallel IR/Raman workers and embedded
+  in exported scripts; charge/spin inference handles ROHF and ECP systems.
+- **Exported scripts** for MP2/CCSD/CCSD(T) now run the requested method
+  instead of a DFT branch.
+- **Solvation** — PCM requested for a calc type that cannot use it is
+  rejected instead of silently ignored; solvated Geometry Optimization works
+  in the SLURM batch worker.
+- **SLURM ingest** keeps computed properties and provenance (dipole, charges,
+  SCF variant, solvent, GPU); reconnecting to a finished SLURM job no longer
+  saves a second copy of its result to History.
+- **SLURM scripts** quote paths containing spaces, and no longer export an
+  unused `QUANTUI_RESULTS_DIR`.
+- **Checkpoints** — PES Scan checkpoint identity is coordinate-aware, and the
+  interactive Frequency run uses its own checkpoint.
+- **NMR** fallback-reference metadata is saved and shown.
+- **Parallel IR/Raman workers** honor density fitting and SCF rescue.
+- **Batch results** carry Mulliken charges and dipoles; UHF Molden export is
+  complete.
+- **Spectra** — the x-range covers every real mode; exported NPZ files carry
+  the fields the cube helper needs, and cube provenance can't be overwritten.
+- **Packaging** — the built wheel ships `quantui.engines`.
+- **Theme** — Plotly axis and zero lines follow the active palette instead of
+  staying pale blue-gray on dark themes.
+
 ## [0.8.2] - 2026-08-30
 
 ### Added
@@ -848,7 +1093,13 @@ Initial public scaffolding of the QuantUI package: `quantui` package with
 `calculator.py`, basic notebook launcher, Apptainer container definition,
 MIT license, and project metadata.
 
-[Unreleased]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.6.1...HEAD
+[Unreleased]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.10.0...HEAD
+[0.10.0]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.9.0...v0.10.0
+[0.9.0]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.8.2...v0.9.0
+[0.8.2]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.8.1...v0.8.2
+[0.8.1]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.8.0...v0.8.1
+[0.8.0]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.7.0...v0.8.0
+[0.7.0]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.6.1...v0.7.0
 [0.6.1]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.5.2...v0.6.0
 [0.5.2]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.5.1...v0.5.2

{quantui-0.8.2/quantui.egg-info → quantui-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantui
-Version: 0.8.2
+Version: 0.10.0
 Summary: An open-source frontend for DFT and post-HF quantum chemistry with PySCF
 Author-email: Jonathan Schultz <nccu-schultz-lab@users.noreply.github.com>
 License: MIT License
@@ -61,11 +61,20 @@ Requires-Dist: kaleido<2,>=0.2.1
 Provides-Extra: pyscf
 Requires-Dist: pyscf<3,>=2.13.0; extra == "pyscf"
 Requires-Dist: pyscf-properties; extra == "pyscf"
+Requires-Dist: pyscf-dispersion>=1.0; extra == "pyscf"
+Provides-Extra: pyfock
+Requires-Dist: pyfock<0.3,>=0.1.7; extra == "pyfock"
+Requires-Dist: ase<4,>=3.22.0; extra == "pyfock"
+Requires-Dist: scipy<2,>=1.10; extra == "pyfock"
+Requires-Dist: numba<0.68,>=0.57; extra == "pyfock"
 Provides-Extra: ase
 Requires-Dist: ase<4,>=3.22.0; extra == "ase"
 Provides-Extra: xtb
 Requires-Dist: xtb>=22.1; extra == "xtb"
 Requires-Dist: ase<4,>=3.22.0; extra == "xtb"
+Provides-Extra: ts
+Requires-Dist: sella>=2.6; extra == "ts"
+Requires-Dist: ase<4,>=3.26; extra == "ts"
 Provides-Extra: app
 Requires-Dist: voila<0.6,>=0.5.0; extra == "app"
 Requires-Dist: ipykernel<8,>=6.0.0; extra == "app"
@@ -77,6 +86,10 @@ Provides-Extra: gpu-cuda13x
 Requires-Dist: gpu4pyscf-cuda13x; extra == "gpu-cuda13x"
 Requires-Dist: cupy-cuda13x; extra == "gpu-cuda13x"
 Requires-Dist: cutensor-cu13; extra == "gpu-cuda13x"
+Provides-Extra: pyfock-gpu-cuda12x
+Requires-Dist: cupy-cuda12x; extra == "pyfock-gpu-cuda12x"
+Provides-Extra: pyfock-gpu-cuda13x
+Requires-Dist: cupy-cuda13x; extra == "pyfock-gpu-cuda13x"
 Provides-Extra: notebook
 Requires-Dist: nbmake>=1.4.0; extra == "notebook"
 Requires-Dist: ipykernel<8,>=6.0.0; extra == "notebook"
@@ -85,6 +98,7 @@ Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
 Requires-Dist: pytest-xdist>=3.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
 Requires-Dist: mypy<2.4,>=1.10; extra == "dev"
 Requires-Dist: types-requests>=2.28.0; extra == "dev"
 Requires-Dist: black~=26.5.1; python_version >= "3.10" and extra == "dev"
@@ -102,7 +116,8 @@ Dynamic: license-file
 [![Python](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11-blue)](https://www.python.org)
 
 A powerful open-source frontend for DFT and post-HF quantum chemistry.
-QuantUI puts [PySCF](https://pyscf.org) behind an interactive Jupyter/Voilà
+QuantUI puts [PySCF](https://pyscf.org) and a guarded
+[PyFock](https://github.com/manassharma07/PyFock) subset behind an interactive Jupyter/Voilà
 UI so you can build molecules, run calculations locally, and visualize the
 results — no cluster account, no SLURM, no queueing.
 
@@ -155,7 +170,11 @@ Real output from QuantUI, straight from the app:
   ready-to-run coordination complexes**, searchable by name/formula), or run a
   structure search by name, SMILES, InChI, PubChem CID, InChIKey, or CAS number
   (PubChem → NCI CACTUS → offline bundled-library fallback; SMILES/InChI resolve
-  locally with no network)
+  locally with no network), or upload a structure file (XYZ, MOL/SDF, MOL2,
+  PDB, CIF, Gaussian input or output)
+- **Structure editing** — set a bond length, angle or dihedral to a value,
+  delete atoms, add a hydrogen, change an element, undo; pick atoms by
+  clicking the viewer. Freeze atoms for a constrained geometry optimization
 - **Offline-first** — runs with no internet: the bundled molecule library and
   the 3D viewer's JavaScript (3Dmol.js) are vendored, so structure lookup and
   every 3D view work in an air-gapped classroom. (Network is used only for the
@@ -165,18 +184,30 @@ Real output from QuantUI, straight from the app:
   router picks the right renderer per task, and a Status-tab toggle persists
   your default-backend preference between sessions
 - **In-session calculations** — RHF, UHF, 9 DFT functionals, MP2, CCSD,
-  CCSD(T), NMR shielding, TD-DFT UV-Vis, and 1D PES scans via PySCF, running
-  in your Python kernel (no batch submission)
+  CCSD(T), NMR shielding, TD-DFT UV-Vis, 1D PES scans, Marcus reorganization
+  energies and **transition-state searches** (Sella, with an automatic
+  frequency check that says whether it found a TS) via PySCF, running
+  in your Python kernel. Optional PyFock 0.1.x adds native-Windows PBE
+  single points and geometry optimizations for neutral, closed-shell molecules
+  with def2-SVP/def2-TZVP, including orbital and population analysis;
+  engine capabilities automatically gate the setup menus
 - **Implicit solvent** — PCM solvation (Water, Ethanol, THF, DMSO,
-  Acetonitrile) via a single checkbox
+  Acetonitrile) via a single checkbox: single points, solvated geometry
+  optimizations, frequencies (PCM Hessian + IR; Raman stays gas-phase) and
+  TD-DFT (non-equilibrium excitations). NMR and PES scans are gas-phase only
 - **Rich results** — total energy, HOMO-LUMO gap, Mulliken charges, dipole
-  moment, thermochemistry (H, S, G at 298 K), IR spectrum chart (stick and
-  Lorentzian-broadened), ¹H/¹³C NMR chemical shifts, orbital energy-level
-  diagram, HOMO/LUMO isosurface (cube-file rendering with toggle for HOMO-1,
-  HOMO, LUMO, LUMO+1), and a side-by-side comparison table for multiple
-  calculations
+  moment, point group, ⟨S²⟩ with a spin-contamination flag for open-shell
+  results, thermochemistry (U, H, S, G, Cv, Cp at any temperature and
+  pressure), IR spectrum chart (stick and Lorentzian-broadened), ¹H/¹³C NMR
+  chemical shifts, an orbital energy-level diagram with symmetry labels
+  (1a₁, 1b₂ …), and a side-by-side comparison table for multiple calculations
+- **Surfaces** — any molecular orbital (α and β for unrestricted results), an
+  **orbital gallery** of the orbitals around the HOMO–LUMO gap in small linked
+  viewers, the electron density, the spin density, and the electrostatic
+  potential mapped on the density surface
 - **Geometry optimization** — BFGS optimizer with step-by-step trajectory
   animation; vibrational frequency analysis with animated normal modes,
+  displacement arrows, an amplitude slider and a table of every mode,
   user-tunable playback FPS, and a per-result-directory disk cache so mode
   switches on repeat visits and history replay are instant
 - **Inorganic / coordination complexes** — first-class support for
@@ -195,14 +226,24 @@ Real output from QuantUI, straight from the app:
   timestamped directory; a built-in browser lets you reload past results
   after a kernel restart; the full `pyscf.log` is shown inline
 - **Structure exports** — download XYZ, MOL/SDF, or PDB files alongside the
-  saved results; script export for a standalone `.py` file
+  saved results; script export for a standalone `.py` file. Every export also
+  downloads straight to your computer, including from a remote
+  Voilà/OnDemand session
 - **Plot export** — save IR, UV-Vis, PES, and orbital diagrams as standalone
   HTML
 - **Optional GPU acceleration** — when [gpu4pyscf](https://github.com/pyscf/gpu4pyscf)
-  and a CUDA-capable NVIDIA GPU are present, SCF calculations auto-offload
+  and a CUDA-capable NVIDIA GPU are present, single-point SCF calculations auto-offload
   via `mf.to_gpu()` (RHF / UHF / RKS / UKS supported; CCSD(T) stays on CPU).
   The Status tab + every result card show which compute device was used.
   Set `QUANTUI_DISABLE_GPU=1` to force CPU even when the GPU is available.
+  Geometry-optimization SCF and gradient steps offload the same way. For a
+  frequency calculation, the displaced IR SCFs offload, but the reference SCF
+  and the analytical Hessian still run on the CPU.
+- **Cluster batch jobs** — `quantui-batch` submits QuantUI calculations to
+  SLURM from a login node over SSH, without starting the image there (presets,
+  chaining from another job's optimized geometry, reruns with more memory or
+  time, results summaries); `quantui submit` does the same wherever QuantUI is
+  installed. See [apptainer/slurm/README.md](https://github.com/The-Schultz-Lab/QuantUI/blob/main/apptainer/slurm/README.md)
 - **Timing calibration** — one-click benchmark suite populates the time
   estimator with real machine data so predictions are accurate from the first run
 - **Voilà app mode** — serve the notebook as a polished widget-only UI (no
@@ -217,11 +258,29 @@ Real output from QuantUI, straight from the app:
 | --- | --- | --- |
 | Linux / macOS | Full | PySCF installs natively |
 | WSL (Windows) | Full | Use an Ubuntu WSL environment |
-| Windows (native) | Partial | All UI and visualization features work; PySCF calculations require the Apptainer container |
+| Windows (native) | Partial | PyFock runs guarded PBE single points and geometry optimizations; use WSL/Apptainer for the full PySCF feature set |
 
-### Windows users: Apptainer container
+### Windows users: native PyFock or the full container
 
-PySCF does not install on Windows natively. The
+For native Windows, install the PyFock subset:
+
+```powershell
+py -3.11 -m venv .venv
+.venv\Scripts\Activate.ps1
+python -m pip install "quantui[pyfock,ase,app]"
+```
+
+In **System Settings → Quantum engine**, select PyFock (or leave Automatic
+selected when PySCF is absent). The validated subset supports neutral,
+closed-shell PBE single points and geometry optimizations with def2-SVP or
+def2-TZVP. Density fitting is always enabled, analytical gradients drive
+optimization, and orbital, Mulliken, dipole, and cube analysis are retained.
+Hybrids, charged/open-shell systems, solvent, and checkpoint warm starts remain
+PySCF-only. Optional PyFock GPU acceleration is available separately through
+CuPy; geometry optimization uses numerical forces on GPU because PyFock 0.1.7
+does not yet provide analytical GPU gradients.
+
+PySCF does not install on Windows natively. For the complete feature set, the
 [`apptainer/quantui.def`](https://github.com/The-Schultz-Lab/QuantUI/blob/main/apptainer/quantui.def) container bundles
 the complete environment and runs anywhere Apptainer/Singularity is available.
 See [`apptainer/README.md`](https://github.com/The-Schultz-Lab/QuantUI/blob/main/apptainer/README.md) for build and run instructions.
@@ -247,6 +306,12 @@ pip install -e ".[pyscf,ase,app]"
 python -m pip install quantui[pyscf,ase,app]
 ```
 
+For the limited native-Windows engine instead:
+
+```bash
+python -m pip install quantui[pyfock,ase,app]
+```
+
 ### Option C — Apptainer container (Windows / reproducible deployment)
 
 See [apptainer/README.md](https://github.com/The-Schultz-Lab/QuantUI/blob/main/apptainer/README.md).
@@ -307,6 +372,40 @@ and result cards will display the compute device.
 Whenever gpu4pyscf can't offload a particular call, QuantUI falls back
 to CPU automatically and the result card reflects which device ran.
 
+### Optional: PyFock GPU acceleration
+
+PyFock uses its own CuPy/Numba CUDA implementation; it does not use
+`gpu4pyscf`. Install the PyFock engine and the CUDA-suffixed CuPy extra that
+matches the NVIDIA driver reported by `nvidia-smi`:
+
+```bash
+# CUDA 13.x driver
+pip install "quantui[pyfock,pyfock-gpu-cuda13x]"
+
+# CUDA 12.x driver
+pip install "quantui[pyfock,pyfock-gpu-cuda12x]"
+```
+
+PyFock GPU use is guarded independently: QuantUI requires CuPy to import and
+report a CUDA device, and still honors the Settings GPU toggle and
+`QUANTUI_DISABLE_GPU=1`. If the probe fails, PyFock falls back to CPU and
+reports the reason. GPU single points use PyFock's GPU SCF/integral/XC path;
+GPU geometry optimizations use numerical finite-difference forces because the
+installed PyFock release's analytical gradient implementation is CPU-only.
+
+### Optional: transition-state searches (Sella)
+
+The **Transition State** calc type uses [Sella](https://github.com/zadorlab/sella),
+installed as an optional extra:
+
+```bash
+pip install "quantui[ts]"
+```
+
+Sella pulls in jax/jaxlib (about 380 MB) and is LGPL-3.0, used as a
+separately installed library. Without it the calc type stays in the menu and
+says how to install it. Local runs only for now (not SLURM batch jobs).
+
 ### Optional: GFN-FF metal pre-optimization (xtb)
 
 The classical (MMFF/UFF) pre-optimizer relies on RDKit's organic valence
@@ -455,8 +554,13 @@ dashboard. After installation:
 quantui log tail -n 50        # last 50 events from event_log.jsonl
 quantui gpu check             # is GPU offload available right now?
 quantui analytics build --open  # build dashboard.html + open in browser
+quantui submit water.xyz --calc frequency --method B3LYP --basis def2-SVP  # SLURM batch job
 ```
 
+On a cluster, `apptainer exec IMAGE quantui install-launcher DIR` writes the
+`quantui-batch` launcher for submitting from a login node — see
+[apptainer/slurm/README.md](https://github.com/The-Schultz-Lab/QuantUI/blob/main/apptainer/slurm/README.md).
+
 Full reference with all flags and examples: [docs/CLI.md](https://github.com/The-Schultz-Lab/QuantUI/blob/main/docs/CLI.md).
 
 ---
@@ -505,11 +609,11 @@ Five step-by-step notebooks in [`notebooks/tutorials/`](https://github.com/The-S
 | PBE | DFT GGA | Large molecules; metals; when speed matters |
 | PBE0 | DFT hybrid | Charge-transfer, band gaps |
 | M06-2X | DFT meta-hybrid | Thermochemistry, barrier heights |
-| wB97X-D | DFT range-sep. + D3 | Non-covalent interactions, excited states |
+| wB97X-D | DFT range-sep. + built-in dispersion | Non-covalent interactions, excited states |
 | CAM-B3LYP | DFT range-sep. | Charge-transfer UV-Vis, Rydberg states |
 | M06-L | DFT local meta-GGA | Large molecules; transition metals |
 | HSE06 | DFT screened hybrid | Band gaps, large molecules |
-| PBE-D3 | DFT GGA + dispersion | Van der Waals complexes, stacking |
+| PBE-D3 | DFT GGA + Grimme D3 (zero damping) | Van der Waals complexes, stacking |
 | MP2 | Post-HF | Accurate energetics for small molecules (O(N⁵)) |
 | CCSD | Post-HF coupled cluster | High-accuracy small-molecule energies (O(N⁶)) |
 | CCSD(T) | Post-HF coupled cluster | Benchmark "gold standard" energies (O(N⁷); CPU only) |
@@ -519,11 +623,13 @@ Five step-by-step notebooks in [`notebooks/tutorials/`](https://github.com/The-S
 | Type | Output |
 | --- | --- |
 | Single Point | Energy, HOMO-LUMO gap, Mulliken charges, dipole moment |
-| Geometry Opt | Optimised structure, trajectory animation |
-| Frequency | Vibrational frequencies, ZPVE, IR intensities, thermochemistry (H/S/G at 298 K), animated normal modes, IR spectrum chart (stick / Lorentzian broadened) |
+| Geometry Opt | Optimised structure, trajectory animation; optional frozen atoms |
+| Transition State | Saddle point near the input geometry (Sella, optional `[ts]` extra), then a frequency check: transition state, minimum, or higher-order saddle point; animated imaginary mode |
+| Frequency | Vibrational frequencies, ZPVE, IR intensities, thermochemistry at any temperature and pressure, animated normal modes, IR spectrum chart (stick / Lorentzian broadened) |
 | UV-Vis (TD-DFT) | Excitation energies, oscillator strengths, UV-Vis spectrum plot |
 | NMR Shielding | ¹H and ¹³C chemical shifts relative to TMS via GIAO; tabulated by element |
 | PES Scan | 1D potential energy surface along a bond, angle, or dihedral; energy profile chart; geometry animation at each scan point |
+| Reorganization Energy | Marcus four-point internal reorganization energy λ = λ₁ + λ₂ for hole (cation) and/or electron (anion) transfer |
 
 ### Basis sets
 
@@ -572,6 +678,8 @@ quantui/                  Main package
   freq_calc.py            Vibrational frequency + thermochemistry
   ir_plot.py              IR spectrum chart (stick / Lorentzian broadened)
   tddft_calc.py           TD-DFT UV-Vis excited-state calculations
+  ts_search.py            Transition-state search (Sella) + frequency check
+  reorganization_energy.py  Marcus four-point reorganization energy
   nmr_calc.py             NMR shielding + ¹H/¹³C chemical shifts
   pes_scan.py             1D potential energy surface scan
   optimizer.py            QM geometry optimization with trajectory
@@ -592,12 +700,14 @@ quantui/                  Main package
   benchmarks.py           Timing calibration benchmark suite
   config.py               Methods, basis sets, solvent/NMR options, presets
   ase_bridge.py           ASE structure I/O
+  batch_launcher.py       Renders the quantui-batch login-node launcher
+  backends/               SLURM batch backend, worker and job registry
   preopt.py               RDKit MMFF94/UFF force-field pre-optimization
   data/                   Bundled library (SQLite + manifests) + vendored 3Dmol.js
 notebooks/
   molecule_computations.ipynb   Main user-facing interface (3-cell launcher)
   tutorials/                    Step-by-step guided notebooks (01–05)
-tests/                    pytest test suite (~1500 tests; run in parallel via pytest-xdist)
+tests/                    pytest test suite (~3,700 tests; run in parallel via pytest-xdist)
 apptainer/                Container definition for reproducible deployment
 local-setup/              Conda environment definition
 pyproject.toml            Package metadata and tool config