Skip to content

Offline laptop app

The same container that runs on a cluster is also a zero-code app you can use with no internet -- on a plane, in a seminar room with flaky wifi, anywhere. Pull the image once while you have a connection; after that everything runs locally in your browser, computing exactly, with your machine's cores/RAM and the compute limits shown right in the GUI.

Easiest: download the one-file app

No Docker, no Python: download the QuiverLab app for your OS, double-click it, and the GUI opens in your browser. One file, fully offline, exact computation (the app runs the pure-exact kernels -- identical results to the accelerated path, which is parity-gated in the test suite). First-open notes for the unsigned binaries are on the download page.

Prefer containers or pip? Both below.

Run it

Pull once (with internet):

apptainer pull quiverlab.sif docker://ghcr.io/marcoarmenta/quiverlab:latest
# or, with Docker:
docker pull ghcr.io/marcoarmenta/quiverlab:latest

Then, offline, start the GUI and open the printed URL:

# Apptainer:
apptainer run quiverlab.sif gui
# Docker (publish the port):
docker run --rm -p 8000:8000 ghcr.io/marcoarmenta/quiverlab:latest gui

Open http://localhost:8000. Draw or pick an algebra, choose a field and what to compute, and read exact results with rendered mathematics -- no code, no account, no network. Math renders from vendored KaTeX, and the print-ready worked-steps HTML report (export to PDF from your browser) is self-contained, so nothing is fetched at runtime.

Memory and time, always visible

Because you are computing on your own hardware, the app is explicit about what that hardware can do. The GUI detects and shows:

  • your machine's cores and RAM (from the container's cgroup-/host-aware probe),
  • an estimate of the size (cells) and time for the example you set up, and
  • an estimate of the memory it will need, next to the worker's memory cap (RLIMIT_AS) -- so you can see the limits you are computing under before you hit them, rather than after.

An example that would blow past your laptop's memory is flagged up front (the same sizing that routes oversized jobs off the instant tier on the web service), so you can shrink the degree range instead of waiting for an out-of-memory stop.

GPUs are irrelevant here: quiverlab is exact CPU arithmetic. If your machine has a GPU it is simply ignored.

Precomputed examples

The image ships a seeded example cache: a curated set of worked examples computed at build time, so opening them is instant and needs no compute at all. When you open one, the GUI notes it was served from the cache.

Sending an example to a cluster

Anything you build in the offline GUI you can also run big on a cluster: use the "Config (YAML)" export button to download the exact config, then follow Run on your HPC cluster. The batch container and the offline app are the same image, so a config that renders here runs there unchanged.

Platform note (honest)

  • Linux: Apptainer or Docker, both work.
  • Windows: Docker Desktop works (docker run -p 8000:8000 ... gui).
  • macOS: use Docker (docker run -p 8000:8000 ... gui) or the pip path below. Apptainer has no native macOS build -- it needs a Linux VM -- so on a Mac the Docker or pip paths are the offline app.

The pip path needs a source checkout (the GUI's webapp/ tree is deliberately not packaged into the wheel) and Python >= 3.10:

git clone https://github.com/MarcoArmenta/quiverlab.git && cd quiverlab
python3.12 -m venv .venv && source .venv/bin/activate   # any Python >= 3.10
pip install -e ".[hpc,web,fast]"
quiverlab-hpc gui        # open http://localhost:8000

It is fully offline too once installed: quiverlab-hpc gui serves the same local app with no network calls, from any working directory.