Metadata-Version: 2.4
Name: vibeviewer
Version: 3.1.0
Summary: GPU-accelerated interactive 3D viewer for quantum-chemistry structures and results
Author-email: "Michael F. Peintinger" <mpei@vibe-qc.com>
License-Expression: MPL-2.0
Project-URL: Homepage, https://vibyverse.com/vibe-viewer
Project-URL: Documentation, https://vibyverse.com/vibe-viewer/docs/
Project-URL: Repository, https://github.com/vibyverse/vibe-viewer
Project-URL: Issues, https://github.com/vibyverse/vibe-viewer/issues
Project-URL: Changelog, https://github.com/vibyverse/vibe-viewer/blob/main/CHANGELOG.md
Keywords: quantum chemistry,visualization,3d viewer,molecular orbitals,electron density,band structure,qvf,pyvista,vtk
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Science/Research
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: Scientific/Engineering :: Chemistry
Classifier: Topic :: Scientific/Engineering :: Physics
Classifier: Topic :: Scientific/Engineering :: Visualization
Requires-Python: >=3.12
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: click>=8.0
Requires-Dist: pydantic>=2.0
Requires-Dist: jsonschema>=4.20
Requires-Dist: numpy>=1.26
Requires-Dist: matplotlib>=3.8
Requires-Dist: pyvista>=0.44
Requires-Dist: plotly>=5.18
Provides-Extra: validation
Requires-Dist: qvf-writer[validate]>=0.8; extra == "validation"
Provides-Extra: viewer
Requires-Dist: trame<4,>=3.6; extra == "viewer"
Requires-Dist: trame-vtk>=2.11.4; extra == "viewer"
Requires-Dist: trame-vuetify>=3.2; extra == "viewer"
Requires-Dist: uvicorn>=0.30; extra == "viewer"
Provides-Extra: capture
Provides-Extra: tui
Requires-Dist: textual>=1.0; extra == "tui"
Provides-Extra: ase
Requires-Dist: ase>=3.22; extra == "ase"
Provides-Extra: results
Requires-Dist: cclib<2,>=1.8; extra == "results"
Provides-Extra: biomolecule
Requires-Dist: gemmi<0.8,>=0.7; extra == "biomolecule"
Provides-Extra: crystal
Requires-Dist: spglib<3,>=2.7; extra == "crystal"
Provides-Extra: trexio
Requires-Dist: trexio>=2.5; python_version < "3.14" and extra == "trexio"
Provides-Extra: smiles
Requires-Dist: rdkit>=2023.3; extra == "smiles"
Provides-Extra: povray
Provides-Extra: blender
Provides-Extra: jupyter
Requires-Dist: ipython; extra == "jupyter"
Requires-Dist: ipywidgets; extra == "jupyter"
Provides-Extra: sysinfo
Requires-Dist: psutil>=5.9; extra == "sysinfo"
Provides-Extra: surfaces
Requires-Dist: scipy>=1.11; extra == "surfaces"
Provides-Extra: queue
Requires-Dist: vibescheduler>=1.0.3; extra == "queue"
Provides-Extra: xtb
Requires-Dist: qvf-writer>=0.7.0rc1; extra == "xtb"
Provides-Extra: sketch
Requires-Dist: vibesketcher>=0.6.4; extra == "sketch"
Provides-Extra: test
Requires-Dist: vibeviewer[crystal]; extra == "test"
Requires-Dist: vibeviewer[viewer]; extra == "test"
Requires-Dist: vibeviewer[tui]; extra == "test"
Requires-Dist: vibeviewer[ase]; extra == "test"
Requires-Dist: vibeviewer[results]; extra == "test"
Requires-Dist: vibeviewer[biomolecule]; extra == "test"
Requires-Dist: vibeviewer[trexio]; extra == "test"
Requires-Dist: vibeviewer[smiles]; extra == "test"
Requires-Dist: vibeviewer[jupyter]; extra == "test"
Requires-Dist: pytest>=8; extra == "test"
Requires-Dist: scipy>=1.11; extra == "test"
Requires-Dist: pyyaml>=6; extra == "test"
Provides-Extra: all
Requires-Dist: vibeviewer[crystal]; extra == "all"
Requires-Dist: vibeviewer[viewer]; extra == "all"
Requires-Dist: vibeviewer[tui]; extra == "all"
Requires-Dist: vibeviewer[ase]; extra == "all"
Requires-Dist: vibeviewer[results]; extra == "all"
Requires-Dist: vibeviewer[biomolecule]; extra == "all"
Requires-Dist: vibeviewer[trexio]; extra == "all"
Requires-Dist: vibeviewer[smiles]; extra == "all"
Requires-Dist: vibeviewer[jupyter]; extra == "all"
Requires-Dist: vibeviewer[sysinfo]; extra == "all"
Requires-Dist: vibeviewer[surfaces]; extra == "all"
Provides-Extra: dev
Requires-Dist: ruff==0.16.8; extra == "dev"
Requires-Dist: mypy==2.3.1; extra == "dev"
Provides-Extra: release
Requires-Dist: build<2,>=1.2; extra == "release"
Requires-Dist: twine<7,>=6; extra == "release"
Requires-Dist: setuptools>=77; extra == "release"
Requires-Dist: wheel>=0.43; extra == "release"
Provides-Extra: docs
Requires-Dist: vibeviewer; extra == "docs"
Requires-Dist: sphinx>=7.4; extra == "docs"
Requires-Dist: myst-parser>=4.0; extra == "docs"
Requires-Dist: linkify-it-py>=2; extra == "docs"
Requires-Dist: furo>=2024.5; extra == "docs"
Requires-Dist: sphinx-copybutton>=0.5; extra == "docs"
Requires-Dist: sphinx-design>=0.6; extra == "docs"
Dynamic: license-file

<!-- attribution -->

_Created and maintained by Dr. Michael F. Peintinger._

# vibe-viewer

The product names are **vibe-viewer** (formerly vibe-view), **vibe-sketcher** (formerly
vibe-sketch), and **vibe-scheduler** (formerly vibe-queue). The former product names and
the `vibe-view` and `vibe-sketch` commands are deprecated aliases that remain supported;
no removal date is scheduled. Viewer **3.0.3** provides `vibe-viewer`; older
installations use the deprecated `vibe-view` command. Verify the separately
installed Sketcher version before using `vibe-sketcher`. Public source snapshots
can lag the canonical releases.
**`vq` is unchanged.** The canonical Python distribution and import are now
`vibeviewer`; `vibeview` remains a compatibility import and command, and
`vibe-view` remains a command alias. Compatibility distribution wheels forward
both old names to `vibeviewer`. Existing state, schemas, plugin groups and
updater identities remain compatible. See [names and migration](docs/naming.md).


Standalone visualization and conversion tools for quantum chemistry results.

vibe-viewer opens [QVF](https://vibyverse.com/vibe-viewer/docs/qvf.html) calculation archives and selected
structure and volume files from many chemistry programs. Use it in a web
browser, a native desktop window, an interactive terminal, a headless figure
pipeline, or Python. vibe-qc is one QVF producer, but it is not required to
install or use the viewer.

The names have different roles:

| Where | Name |
|---|---|
| Product | `vibe-viewer` |
| Preferred command (3.0.3 and later) | `vibe-viewer` |
| Compatibility commands | `vibeview`, `vibe-view` |
| Compatibility Python import | `vibeview` |
| Python distribution and import package | `vibeviewer` |
| Git repository | `vibyverse/vibe-viewer` |

## Install

The examples use `vibe-viewer`, available in release **3.0.3** and later.
For older installations, the deprecated `vibe-view` alias remains supported;
see [names and compatibility](docs/naming.md). Public source snapshots may
lag the canonical release, so check the installed version before continuing.

Prerequisites are Python 3.12 or newer and Git. Debian and Ubuntu users also
need the matching `python3-venv` package. Docker is not used, and no C++
compiler or vibe-qc native dependency build is required.

Clone the public source repository:

```sh
git clone https://github.com/vibyverse/vibe-viewer.git
```

Enter the standalone repository and install:

```sh
cd vibe-viewer
./scripts/install.sh
source .venv/bin/activate
```

GitLab remains the canonical development service. Maintainers provide its
connection details separately to authorized contributors. Public snapshots can
lag development; check the available public tags when selecting a release.

The installer is for macOS and Linux. It creates a dedicated environment
under `.venv` at the repository root and installs the standalone CLI, browser viewer,
source-checkout desktop command, and interactive TUI. Electron downloads
automatically the first time you run `vibe-viewer desktop`; pass
`--with-electron` to download it during installation instead. It does not
build or install vibe-qc. Run every lifecycle script as your regular login
user, without `sudo`, so the checkout, environment, and Electron runtime keep
one consistent owner.

Here, standalone means a dedicated Python environment that does not install or
build vibe-qc. The checkout is self-contained: vibe-viewer vendors its own copies
of the QVF manifest schemas and ships its Electron source, so nothing outside
this repository has to be present. (Before the 2026-09 split the schemas were
symlinks into vibe-qc's tree and the viewer had to live inside that checkout;
they are real data files now, and the built wheel carries them.)

Two optional desktop integrations make the source install behave like a
native app on macOS:

```sh
./scripts/install.sh --with-electron --dock \
    --link-bin /opt/homebrew/bin
```

`--dock` pins the source-backed `vibe-view.app` to the macOS Dock, and
`--link-bin DIR` writes marked `vibe-viewer` and deprecated `vibe-view` launchers into an existing,
writable directory on your PATH (Homebrew macOS: `/opt/homebrew/bin`;
`~/.local/bin` when it is on PATH), so `vibe-viewer desktop FILE.qvf` works
from any shell. `--adopt-desktop` lets this checkout take over a source app
installed by another checkout. Both integrations are recorded:
`uninstall.sh` removes them with the installation, and re-running
`install.sh` with the same flags refreshes them after the checkout or
environment moves.

Update the current branch and environment with one command:

```sh
./scripts/update.sh          # current branch
./scripts/update.sh --dev    # switch to and update main
./scripts/update-desktop.sh  # source + Python + desktop app
```

Git-aware viewer updates operate on this repository. With no
selector the updater fast-forwards the current branch; `--dev`, `--release`,
and `--branch NAME` can switch the whole checkout. Use `--skip-git` when you
only want to reinstall the currently checked-out source.

Repair or remove a standalone source installation without manual virtualenv
steps. First quit every vibe-viewer desktop window and any running vibe-viewer CLI
or browser-server launch:

```sh
./scripts/reinstall.sh           # rebuild modes, keep Git unchanged
./scripts/reinstall.sh --desktop # also refresh Electron + source app
./scripts/uninstall.sh --dry-run
./scripts/uninstall.sh
```

Reinstall is transactional: it keeps the previous environment until the new
one installs and verifies successfully. Uninstall removes the dedicated viewer
environment, a recognizable direct-download Electron runtime in this checkout,
a macOS source app owned by this checkout, and the Dock tile / command link
created by `install.sh --dock` / `--link-bin`. It never removes packaged
apps, apps owned by another checkout, QVF files, settings, recents, logs, or the
app-managed environment under `$XDG_DATA_HOME/vibe-view/venv`. Pass
`--keep-desktop` to retain the Electron download and source app.
The cached interpreter selection is removed only when it points into the
environment being deleted; other user data and window state remain.

For a side-by-side comparison of install, update, repair, and removal across
vibe-viewer, vibe-qc, vq, and vibe-basis, see the
[toolset lifecycle guide](https://vibyverse.com/vibe-qc/docs/) (`docs/toolset_lifecycle.md`
in the vibe-qc repository). It also covers profile
selection, ownership markers, legacy adoption, and what each uninstall keeps.

## Build a local wheel

The lifecycle installer also installs the Python `build` frontend needed by the
local wheel helper:

```sh
./scripts/install.sh
./scripts/build.sh
```

`build.sh` auto-detects `.venv`, cleans the local viewer build output,
and writes `dist/vibeviewer-*.whl`. For a custom environment, set
`VIBE_VIEW_VENV=/path/to/venv` or
`VIBE_VIEW_VENV_PYTHON=/path/to/python`. If it reports `no usable vibe-viewer
virtualenv found`, run `install.sh`; if it reports a missing `build` frontend,
run `update.sh --skip-git`.

`make_wheel.sh` is the separate release-publisher workflow. It builds and
validates the wheel and source distribution, writes checksums, and stages the
website download. Use `build.sh` for ordinary local packaging.

Quit the desktop window before running `update-desktop.sh`. It refreshes the
source-backed Electron app owned by this checkout, including its displayed
vibe-viewer version, and synchronizes the Electron engine to the reviewed
lockfile version. It never overwrites an app installed from a DMG; a published
macOS package uses Help > Check for Updates, while other packaged builds need
the current replacement artifact. On Linux it updates the Electron runtime and
wrappers, and the app continues to launch through `vibe-viewer desktop`; Linux
has no Applications copy. `install.sh --with-electron` downloads the runtime
and installs the macOS Applications copy in the same step. If a source app
belongs to an older checkout, review the path it reports and pass
`--adopt-desktop` explicitly to transfer ownership. Branch, tag, and commit
selectors are accepted only when the selected revision contains the safe
desktop-update protocol.

Use `--extras core`, `viewer`, `tui`, or `all` to choose a smaller or broader
profile. Electron and desktop options require `modes`, `viewer`, `all`, or
`test`; `core` and `tui` remain non-desktop profiles. Run the scripts with
`--help` for Python, venv, and recovery options; the updater also documents its
branch and release selectors. Update and reinstall default to `modes`, so
repeat `--extras` when maintaining a non-default profile.

> **Note:** the private package index at `https://vibe-qc.com/pypi/simple/` is
> planned but is **not published yet**, so
> `pip install vibeviewer --index-url https://vibe-qc.com/pypi/simple/` will not
> resolve. Bare `pip install vibeviewer` and `pipx install vibeviewer` do not work
> yet either. Use the checkout installer above; see the
> [installation and downloads guide](https://vibyverse.com/vibe-viewer/docs/installation.html).

> **Downloads:** use the standalone repository’s source archives or validated
> build artifacts, described in the installation guide. The old 2.15.2 wheel
> under the producer’s documentation is a historical artifact, not the current
> viewer. A GitHub source mirror does not imply published wheel or desktop assets.


## Features

- **ORCA calculations** — open an ORCA 6.1 run as one dataset: structures, charges and Mayer bond orders from the property text or JSON, orbitals from the exported JSON or the GBW file (through ORCA's `orca_2json`), vibrations with IR and Raman from the Hessian and VCD from the output log, UV-Vis, ECD and MCD spectra; prepare an ORCA input from an edited structure and submit it through vq ([step by step](docs/orca.md), [worked water example](docs/orca_water.md), [Raman/VCD along normal modes](docs/orca_raman_vcd.md))
- **Structure** — CPK-coloured atoms with ball-and-stick, space-filling, wireframe styles
- **Electron density** — translucent isosurface with adjustable isovalue and colormap
- **Molecular orbitals** — HOMO/LUMO and full MO set with signed-lobe rendering
- **Excited states** — TD-DFT and similar `excited_states` sections as a table of energies, wavelengths, oscillator and rotatory strengths, symmetries and orbital contributions, linked to their natural transition orbitals and transition densities
- **Direct volume rendering** — ray-cast densities and orbitals with a transfer-function editor, beside the isosurface view
- **Publication figures** — view presets, outlines and a chrome-free figure look; PNG, SVG and PDF export at a chosen scale
- **Band structure + DOS** — Interactive Plotly charts with Fermi-level reference
- **Compare mode** — Overlay structures from multiple files with Kabsch alignment
- **Bookmarks, sessions and slides** — save a view with the structure on show, restore it later, present the bookmarks as a slideshow
- **vibe-sketcher hand-off** — draw a molecule in 2D in [vibe-sketcher](https://vibe-qc.com) and open it here with its charge and multiplicity ([editing](docs/editing.md))
- **Vibrations** — Animated normal modes; combine selected modes with independent signed displacements, export the geometry and calculate it through ORCA/vq ([worked example](docs/orca_raman_vcd.md#combine-selected-modes))
- **IR/UV-Vis/Raman/VCD spectra** — Stem plots with hover tooltips and signed VCD strengths
- **Wavefunction evaluator** — On-demand orbital evaluation from GTO basis
- **Geometry optimisation trajectory** — Frame-by-frame playback with energy plot
- **Bond orders + QTAIM** — Mayer/Wiberg analysis with critical points and bond paths
- **vq Job Manager** — live queue cockpit: monitor vibe-scheduler jobs by state and fetch results straight into the viewer ([guide](https://vibyverse.com/vibe-viewer/docs/queue.html))
- **Biomolecule metadata** — QVF `structure` sections carry optional chains / residues / secondary structure for cartoon rendering
- **Terminal mode** — full 3D viewer, charts and selectable wavefunction surfaces as Unicode braille in any terminal: canonical, alpha/beta, natural and localized orbitals plus computed density, with no display server, GL or X forwarding ([guide](https://vibyverse.com/vibe-viewer/docs/capabilities.html))
- **Jupyter notebooks** — `%vibeviewer` renders structures, volume captures, tables, SCF histories, and bands inline (requires the `[jupyter]` extra)
- **Import** — QVF, vibe-qc Python inputs (`.py`), XYZ, CIF, Cube, PDB, Mol2, Gaussian input, GRO, SDF/Mol; ORCA calculations with structure, property spectra, MCD sticks and supported orbitals together ([ORCA tutorial](docs/orca.md)); TREXIO geometry and Gaussian orbitals through the optional `[trexio]` extra ([TREXIO guide](docs/formats.md#trexio-wavefunctions))
- **Export** — XYZ, CIF, OBJ, glTF, HTML (standalone 3D viewer), JSON

## Quickstart

```sh
vibe-viewer doctor             # check this installation and its optional modes
vibe-viewer demo               # write and validate a bundled water structure demo
vibe-viewer demo --open        # write it, then launch the browser viewer
```

`demo` needs neither vibe-qc nor an input file. It prints browser, desktop,
terminal, and headless next steps. Use `-o FILE` to choose its output path and
`--force` to replace an existing demo. The older `vibe-viewer quickstart`
command runs a real calculation and therefore requires vibe-qc in the same
environment.

Already have data? Choose the shortest route:

| Goal | Command |
|---|---|
| Open a QVF or supported loose file in a browser | `vibe-viewer open INPUT` |
| Inspect an ORCA calculation with its companions | `vibe-viewer open calculation.property.json` — [step-by-step tutorial](docs/orca.md) |
| Work over SSH without a display | `vibe-viewer show FILE.qvf` or `vibe-viewer tui FILE.qvf` |
| Use a native window from the source checkout | `vibe-viewer desktop INPUT` |
| See which loose formats this installation supports | `vibe-viewer formats` |
| Convert a loose file into a persistent QVF | `vibe-viewer import INPUT` |

The wheel contains the Python browser, terminal, and headless surfaces, but
not the Electron source used by `vibe-viewer desktop`. Desktop mode currently
uses a source checkout; signed standalone desktop artifacts have not landed.

## CLI commands

```
open             Interactive 3D viewer
demo             Write a bundled water structure demo (--open launches the browser)
tui              Interactive terminal viewer (needs the [tui] extra)
show             Render one frame as terminal text and exit
compare          Side-by-side with auto compare-mode
serve            Web-based QVF file browser
dashboard        Grid preview of several QVF files
desktop          Launch the native Electron window (source checkout)
table            Dump tabular data (table/csv/json)
batch            Offscreen PNG gallery (+ --volumes)
batch-compare    Batch side-by-side comparisons
info             Metadata + section sizes (--json, --short)
export           XYZ/CIF/CML/JSON/PY structure, OBJ/glTF meshes,
                 POV-Ray/Blender scenes, HTML/SVG/PDF pages (12 formats)
animate          Render animated sections (trajectory, NEB, vibrations) to MP4/GIF
diff             Compare two QVFs (--json)
validate         Strict QVF reference validation (requires [validation])
import           Convert loose inputs into persistent QVF archives
formats          List built-in and plugin importers (--json for scripts)
capture          Render any section to PNG
capture-selftest Self-test the headless capture pipeline
slice            Extract subset of sections
merge            Combine sections from multiple QVFs
supercell        Replicate a periodic structure
h-add            Add hydrogens to a structure
from-vq          Fetch a finished vq job's QVF output
vq-features      Report vq integration feature availability
config           Manage configuration (~/.config/vibe-view/)
doctor           Diagnose the installation and optional modes (--json)
recent           Recently opened files
stats            Directory-wide statistics
examples         Show workflows; --copy DIR copies bundled examples
quickstart       Run a vibe-qc calculation and open it (requires vibe-qc)
```

## Python SDK

```python
from vibeviewer import info, diff, validate, get_structure, capture_structure, render_terminal

data = info("calculation.qvf")
comparison = diff("hf.qvf", "pbe.qvf")
validation = validate("result.qvf")  # requires the optional reference validator
print(validation["valid"])
capture_structure("h2o.qvf", "structure.png")

# Same renderers, text instead of a PNG — and no OpenGL context needed,
# so this one works on a headless compute node.
print(render_terminal("h2o.qvf", size=(80, 24)))
print(render_terminal("h2o.qvf", "vol_mo_3", isovalue=0.03))
```

Strict validation needs qvf’s reference package in addition to the core
viewer; follow [the validation setup](docs/qvf.md#strict-validation). The
returned value is a report dictionary: inspect its `valid` field rather than
testing the dictionary itself for truth.

`render_terminal` draws stored `volume.*` sections in one shot. To browse
every orbital embedded in `wavefunction.gto`, including localized and natural
sets, run `vibe-viewer tui h2o.qvf`; use the focusable surface table on the
right, or `n`/`p`, `D`, and `S` from the keyboard. `D` is available when the
archive declares electron occupations; transition weights and ambiguous
legacy natural values remain orbital-only. On-demand evaluation covers
shells through `l = 3`; periodic Gamma fields omit image-AO tails. The status
line reports an incomplete high-l surface.

## Jupyter

Jupyter support is optional. Use the source installer's `all` profile, or the
wheel's `[jupyter]` extra, in the environment that runs the notebook kernel.

```python
%load_ext vibeviewer.jupyter
%vibeviewer calculation.qvf
%vibeviewer calculation.qvf --table atom_properties
```

Run `%vibeviewer --help` for `--capture`, `--table`, `--mo`, `--scf`, and
`--bands`.

## Documentation

<https://vibyverse.com/vibe-viewer/docs/> — the manual: install and quickstart, a
panel-by-panel tour, the browser viewer and its editor, terminal mode, the
desktop app, headless figures and exports, input formats and importer plugins,
biomolecules, the QVF format, jobs and live results, the `[queue]` extra, the
CLI, the Python SDK and troubleshooting.

Build it from a checkout:

```sh
pip install -e '.[docs]'  # the Sphinx toolchain, pinned in pyproject.toml
make -C docs html        # renders into docs/_build/html
make -C docs strict      # the same build with -W; run this before pushing docs
```

> The published site tracks the `release` branch, so it shows the released
> version; a local build shows the tip of your checkout. See
> [`docs/release_process.md`](docs/release_process.md).

## License

MPL 2.0 — see [LICENSE](LICENSE).


## History

vibe-viewer was split from the vibe-qc monorepo on 2026-09-08. It is now an
independently versioned companion to [vibe-qc](https://github.com/vibyverse/vibe-qc),
[vibe-scheduler](https://github.com/vibyverse/vibe-scheduler) and
[qvf](https://github.com/vibyverse/qvf).

The canonical development history remains private. Public snapshots have new
commit identities and record their source revision and per-file checksums in
publication provenance. A public commit ID is not interchangeable with a
canonical development commit ID; original release tags remain immutable.

The QVF manifest schema `src/vibeviewer/schema.json` is a byte-identical copy
from the release of the [qvf repository](https://github.com/vibyverse/qvf) that
`QVF_TAG` pins; qvf is the single master of the format, and vibe-viewer vendors
nothing else. `scripts/check_qvf_conformance.py` checks the copy, its pin and
the conformance corpus.

Copyright (c) 2026 Michael F. Peintinger and vibe-qc contributors.

## How to cite

Please cite Michael F. Peintinger, *VIBE-VIEW and QVF: portable visualization
and checksummed archives for quantum chemistry*, ChemRxiv (2026), version 1,
[doi:10.26434/chemrxiv.15010122/v1](https://doi.org/10.26434/chemrxiv.15010122/v1).
The program was renamed from **vibe-view** to **vibe-viewer**; the preprint retains its original title.
vibe-viewer is part of the vibyverse, so also cite Michael F. Peintinger,
*vibyverse: an integrated computational chemistry ecosystem developed through
agentic engineering*, ChemRxiv (2026), version 1,
[doi:10.26434/chemrxiv.15011786/v1](https://doi.org/10.26434/chemrxiv.15011786/v1).
See [How to cite](docs/citation.md) for BibTeX and the preprint status.
