grace-runtime 0.0.0.dev0__tar.gz → 0.1.0__tar.gz

grace_runtime-0.1.0/.github/workflows/cpu-wheels.yml

@@ -0,0 +1,111 @@
+# CPU package grace-runtime: libgrace C++ tests, the sdist and the wheels (CPython 3.10, 3.11 and one abi3 wheel for
+# >= 3.12; scripts/build_wheels.sh, no Docker) for manylinux2014 x86_64 and, on GitHub's ARM runner, macOS arm64, then
+# each wheel in clean environments (scripts/test_wheels.sh). The wheels are kept as the artifacts "cpu-wheels" (x86_64
+# and the sdist) and "cpu-wheels-macos-arm64". Linux aarch64 (scripts/build_wheels.sh can build it) is not released
+# until it has been tested: add {artifact: cpu-wheels-linux-aarch64, os: ubuntu-24.04-arm, mamba: linux-aarch64}.
+name: CPU wheels
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [dev]      # the release pull request
+  workflow_call:         # from release.yml
+
+permissions:
+  contents: read
+
+env:
+  TEST_MODELS: "GRACE-2L-SMAX-OMAT-medium GRACE-1L-OMAT-large-base GRACE-2L-OMAT-medium-ft-E GRACE-3L-OMAT-large GRACE-2L-SMAX-OMAT-large"
+
+jobs:
+  ctest:
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - name: micromamba
+        run: |
+          mkdir -p ~/.mm && curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C ~/.mm bin/micromamba
+          echo "MAMBA_EXE=$HOME/.mm/bin/micromamba" >> "$GITHUB_ENV"
+          echo "MAMBA_ROOT_PREFIX=$HOME/micromamba" >> "$GITHUB_ENV"
+          echo "GRACE_CACHE=$HOME/grace-cache" >> "$GITHUB_ENV"
+      - uses: actions/cache@v4
+        with:
+          path: ~/grace-cache
+          key: grace-test-models-v2
+      - name: environment and test models
+        run: |
+          $MAMBA_EXE create -y -q -n gn-ctest -c conda-forge python=3.12 gxx_linux-64 "sysroot_linux-64=2.17" cmake ninja pip numpy ase tqdm
+          $MAMBA_ROOT_PREFIX/envs/gn-ctest/bin/python scripts/download_test_models.py $TEST_MODELS
+          $MAMBA_ROOT_PREFIX/envs/gn-ctest/bin/python -c "import sys; sys.path.insert(0, 'python/tests'); from model_tools import strip_uq; strip_uq('$GRACE_CACHE/GRACE-2L-SMAX-OMAT-medium/kokkos.npz', 'nouq.npz')"
+      - name: build and ctest (x86-64-v3 flags, which every runner CPU runs)
+        run: |
+          export GRACE_TEST_NOUQ=$PWD/nouq.npz
+          $MAMBA_EXE run -n gn-ctest cmake -S . -B build-ci -G Ninja -DCMAKE_BUILD_TYPE=Release "-DGRACE_ARCH_FLAGS=-march=x86-64-v3"
+          $MAMBA_EXE run -n gn-ctest cmake --build build-ci -j "$(nproc)"
+          cd build-ci && $MAMBA_EXE run -n gn-ctest ctest --output-on-failure
+
+  wheels:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - {artifact: cpu-wheels, os: ubuntu-latest, mamba: linux-64}
+          - {artifact: cpu-wheels-macos-arm64, os: macos-14, mamba: osx-arm64}
+    runs-on: ${{ matrix.platform.os }}
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - name: micromamba
+        run: |
+          mkdir -p ~/.mm && curl -Ls https://micro.mamba.pm/api/micromamba/${{ matrix.platform.mamba }}/latest | tar -xj -C ~/.mm bin/micromamba
+          echo "MAMBA_EXE=$HOME/.mm/bin/micromamba" >> "$GITHUB_ENV"
+      - name: build
+        run: bash scripts/build_wheels.sh dist/wheelhouse
+      - name: the sdist from the x86_64 runner only
+        if: matrix.platform.artifact != 'cpu-wheels'
+        run: rm -f dist/wheelhouse/*.tar.gz
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.platform.artifact }}
+          path: |
+            dist/wheelhouse/*.whl
+            dist/wheelhouse/*.tar.gz
+          if-no-files-found: error
+
+  test-wheels:
+    needs: wheels
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - {artifact: cpu-wheels, os: ubuntu-latest, mamba: linux-64}
+          - {artifact: cpu-wheels-macos-arm64, os: macos-14, mamba: osx-arm64}
+        python: ["3.10", "3.11", "3.12", "3.13"]
+    runs-on: ${{ matrix.platform.os }}
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+      - name: micromamba
+        run: |
+          mkdir -p ~/.mm && curl -Ls https://micro.mamba.pm/api/micromamba/${{ matrix.platform.mamba }}/latest | tar -xj -C ~/.mm bin/micromamba
+          echo "MAMBA_EXE=$HOME/.mm/bin/micromamba" >> "$GITHUB_ENV"
+          echo "MAMBA_ROOT_PREFIX=$HOME/micromamba" >> "$GITHUB_ENV"
+          echo "GRACE_CACHE=$HOME/grace-cache" >> "$GITHUB_ENV"
+      - uses: actions/download-artifact@v4
+        with:
+          name: ${{ matrix.platform.artifact }}
+          path: dist/wheelhouse
+      - uses: actions/cache@v4
+        with:
+          path: ~/grace-cache
+          key: grace-test-models-v2
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: test models
+        run: |
+          python -m pip install -q tqdm
+          python scripts/download_test_models.py $TEST_MODELS
+      - name: test the CPython ${{ matrix.python }} wheel
+        run: PYTHONS=${{ matrix.python }} bash scripts/test_wheels.sh dist/wheelhouse

grace_runtime-0.1.0/.github/workflows/cuda-wheels.yml

@@ -0,0 +1,96 @@
+# NVIDIA GPU package grace-runtime-cuda12: one job per GPU architecture builds Kokkos (cached) and that architecture's
+# module for CPython 3.10, 3.11 and >= 3.12 (abi3) (scripts/build_cuda_wheels.sh: CUDA 12.9 and conda-forge compilers
+# with the glibc 2.17 sysroot, no Docker, no CUDA toolkit on the runner); scripts/merge_cuda_wheels.py then makes one
+# wheel per CPython tag with all modules. The runners have no GPU: the check job tests the wheels' contents and that
+# device="auto" runs on the CPU without a GPU; the GPU tests are scripts/test_cuda_wheels.sh on a GPU machine.
+# The wheels and the sdist are kept as the artifact "cuda-wheels".
+name: CUDA wheels
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [dev]      # the release pull request
+  workflow_call:         # from release.yml
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 360
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [sm70, sm80, sm90, sm100, sm120]
+    steps:
+      - uses: actions/checkout@v4
+      - name: micromamba
+        run: |
+          mkdir -p ~/.mm && curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C ~/.mm bin/micromamba
+          echo "MAMBA_EXE=$HOME/.mm/bin/micromamba" >> "$GITHUB_ENV"
+          # nvcc needs up to ~3 GB per process
+          M=$(free -g | awk '/^Mem:/{print $2}'); echo "NPROC=$(( M / 3 > 0 ? M / 3 : 1 ))" >> "$GITHUB_ENV"
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/grace-runtime/kokkos-wheel/install-*-${{ matrix.arch }}
+          key: kokkos-${{ matrix.arch }}-${{ hashFiles('python-cuda/CMakeLists.txt', 'scripts/build_cuda_wheels.sh') }}
+      - name: build
+        run: GRACE_KK_ARCHS=${{ matrix.arch }} bash scripts/build_cuda_wheels.sh dist/cuda-${{ matrix.arch }}
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cuda-${{ matrix.arch }}
+          path: |
+            dist/cuda-${{ matrix.arch }}/*.whl
+            dist/cuda-${{ matrix.arch }}/*.tar.gz
+          if-no-files-found: error
+
+  merge-and-check:
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: cuda-sm*
+          path: dist/parts
+      - name: micromamba
+        run: |
+          mkdir -p ~/.mm && curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C ~/.mm bin/micromamba
+          echo "MAMBA_EXE=$HOME/.mm/bin/micromamba" >> "$GITHUB_ENV"
+          echo "MAMBA_ROOT_PREFIX=$HOME/micromamba" >> "$GITHUB_ENV"
+          echo "GRACE_CACHE=$HOME/grace-cache" >> "$GITHUB_ENV"
+      - name: merge (one wheel per CPython tag with all modules)
+        run: |
+          $MAMBA_EXE create -y -q -n gn-cudachk -c conda-forge python=3.12 pip numpy ase tqdm auditwheel binutils
+          $MAMBA_ROOT_PREFIX/envs/gn-cudachk/bin/python scripts/merge_cuda_wheels.py dist/cuda-wheelhouse dist/parts/cuda-sm*/*.whl
+          cp "$(ls dist/parts/cuda-sm80/*.tar.gz)" dist/cuda-wheelhouse/
+          ls -la dist/cuda-wheelhouse
+      - name: check the wheels' contents
+        run: |
+          for w in dist/cuda-wheelhouse/*.whl; do
+            $MAMBA_ROOT_PREFIX/envs/gn-cudachk/bin/python scripts/check_cuda_wheel.py "$w" sm70,sm80,sm90,sm100,sm120
+          done
+      - name: without a GPU, device="auto" runs on the CPU (no warning)
+        run: |
+          PYTHONS=3.12 bash scripts/build_wheels.sh dist/wheelhouse    # the CPU package it plugs into
+          P=$MAMBA_ROOT_PREFIX/envs/gn-cudachk/bin
+          $P/python -m pip install -q dist/wheelhouse/*cp312-abi3*.whl dist/cuda-wheelhouse/*cp312-abi3*.whl
+          $P/grace-runtime models download GRACE-1L-OMAT-large-base
+          cd /tmp && $P/python -W error::RuntimeWarning - <<'PY'
+          import os, grace_runtime, grace_runtime._cuda as c
+          print("plug-ins:", [p.__name__ for p in c.plugins()], "modules:", c.available())
+          assert "grace_runtime_cuda12" in [p.__name__ for p in c.plugins()]
+          os.environ.pop("GRACE_RUNTIME_DEVICE", None)
+          calc = grace_runtime.GRACERuntimeCalculator("GRACE-1L-OMAT-large-base")
+          assert calc.backend == "cpu", calc.backend
+          print("no GPU: device='auto' ->", calc.backend)
+          PY
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cuda-wheels
+          path: |
+            dist/cuda-wheelhouse/*.whl
+            dist/cuda-wheelhouse/*.tar.gz
+          if-no-files-found: error

grace_runtime-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,88 @@
+# A published GitHub release X.Y.Z builds the packages (the CPU wheels and CUDA wheels workflows) and uploads them by
+# Trusted Publishing. A pre-release goes to TestPyPI (environment "testpypi"), a release to PyPI (environment "pypi");
+# every upload waits for an approval in its environment. grace-runtime goes first and on its own; grace-runtime-cuda12
+# and grace-runtime-rocm6 (which pin grace-runtime==X.Y.Z) are built and follow only when the repository variables
+# GRACE_RELEASE_CUDA / GRACE_RELEASE_ROCM are "true". GRACE_ROCM_ARCHS (a JSON list) overrides the AMD architectures.
+# The files must carry the version of the release tag.
+name: Release
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  cpu:
+    uses: ./.github/workflows/cpu-wheels.yml
+
+  publish-cpu:
+    needs: cpu
+    runs-on: ubuntu-latest
+    environment: ${{ github.event.release.prerelease && 'testpypi' || 'pypi' }}
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: cpu-wheels*    # x86_64 and the sdist, macOS arm64
+          merge-multiple: true
+          path: dist
+      - name: version = release tag
+        run: |
+          T=${{ github.event.release.tag_name }}; ls dist
+          for f in dist/*; do case "$(basename "$f")" in grace_runtime-$T-*.whl|grace_runtime-$T.tar.gz) ;; *) echo "::error::$f is not version $T"; exit 1 ;; esac; done
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: ${{ github.event.release.prerelease && 'https://test.pypi.org/legacy/' || 'https://upload.pypi.org/legacy/' }}
+
+  cuda:
+    if: vars.GRACE_RELEASE_CUDA == 'true'
+    uses: ./.github/workflows/cuda-wheels.yml
+
+  publish-cuda:
+    if: vars.GRACE_RELEASE_CUDA == 'true'
+    needs: [cuda, publish-cpu]
+    runs-on: ubuntu-latest
+    environment: ${{ github.event.release.prerelease && 'testpypi' || 'pypi' }}
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: cuda-wheels
+          path: dist
+      - name: version = release tag
+        run: |
+          T=${{ github.event.release.tag_name }}; ls dist
+          for f in dist/*; do case "$(basename "$f")" in grace_runtime_cuda12-$T-*.whl|grace_runtime_cuda12-$T.tar.gz) ;; *) echo "::error::$f is not version $T"; exit 1 ;; esac; done
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: ${{ github.event.release.prerelease && 'https://test.pypi.org/legacy/' || 'https://upload.pypi.org/legacy/' }}
+
+  rocm:
+    if: vars.GRACE_RELEASE_ROCM == 'true'
+    uses: ./.github/workflows/rocm-wheels.yml
+    with:
+      archs: ${{ vars.GRACE_ROCM_ARCHS || '["gfx90a","gfx942"]' }}
+
+  publish-rocm:
+    if: vars.GRACE_RELEASE_ROCM == 'true'
+    needs: [rocm, publish-cpu]
+    runs-on: ubuntu-latest
+    environment: ${{ github.event.release.prerelease && 'testpypi' || 'pypi' }}
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: rocm-wheels
+          path: dist
+      - name: version = release tag
+        run: |
+          T=${{ github.event.release.tag_name }}; ls dist
+          for f in dist/*; do case "$(basename "$f")" in grace_runtime_rocm6-$T-*.whl|grace_runtime_rocm6-$T.tar.gz) ;; *) echo "::error::$f is not version $T"; exit 1 ;; esac; done
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: ${{ github.event.release.prerelease && 'https://test.pypi.org/legacy/' || 'https://upload.pypi.org/legacy/' }}

grace_runtime-0.1.0/.github/workflows/rocm-wheels.yml

@@ -0,0 +1,112 @@
+# AMD GPU package grace-runtime-rocm6, started by hand or from release.yml (not on pull requests).
+# One job per GPU architecture builds Kokkos (cached) and that architecture's module for CPython 3.10, 3.11 and >= 3.12
+# (abi3) in the manylinux_2_28 image (scripts/build_rocm_wheels.sh: the image's g++, ROCm 6.2.4 from AMD's RHEL 8
+# packages, unpacked without root); scripts/merge_cuda_wheels.py then makes one wheel per CPython tag with all modules.
+# The wheels need ROCm 6 on the user's machine (libamdhip64.so.6); they bundle no ROCm library (rocBLAS is loaded at run
+# time when present). The runners have no GPU: the check job tests the wheels' contents and that device="auto" runs on
+# the CPU without a GPU; the GPU tests are scripts/test_rocm_wheels.sh on an AMD GPU machine.
+# The wheels and the sdist are kept as the artifact "rocm-wheels".
+name: ROCm wheels
+
+on:
+  workflow_dispatch:
+    inputs:
+      archs:
+        description: 'GPU architectures, a JSON list, e.g. ["gfx90a","gfx942","gfx1100","gfx1201"]'
+        type: string
+        default: '["gfx90a","gfx942"]'
+  workflow_call:         # from release.yml
+    inputs:
+      archs:
+        type: string
+        default: '["gfx90a","gfx942"]'
+
+permissions:
+  contents: read
+
+env:
+  IMAGE: quay.io/pypa/manylinux_2_28_x86_64:2026.10.16-1
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 240
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: ${{ fromJSON(inputs.archs) }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/grace-runtime/kokkos-rocm-wheel/install-*-${{ matrix.arch }}
+          key: kokkos-rocm-${{ matrix.arch }}-${{ env.IMAGE }}-${{ hashFiles('python-rocm6/CMakeLists.txt', 'scripts/build_rocm_wheels.sh') }}
+      - name: build (manylinux_2_28 image)
+        run: |
+          mkdir -p ~/.cache/grace-runtime
+          docker run --rm -v "$PWD:/io" -v "$HOME/.cache/grace-runtime:/root/.cache/grace-runtime" -w /io \
+            -e GRACE_KK_ARCHS=${{ matrix.arch }} -e NPROC="$(nproc)" "$IMAGE" \
+            bash scripts/build_rocm_wheels.sh dist/rocm-${{ matrix.arch }}
+          sudo chown -R "$(id -u):$(id -g)" dist ~/.cache/grace-runtime
+      - uses: actions/upload-artifact@v4
+        with:
+          name: rocm-${{ matrix.arch }}
+          path: |
+            dist/rocm-${{ matrix.arch }}/*.whl
+            dist/rocm-${{ matrix.arch }}/*.tar.gz
+          if-no-files-found: error
+
+  merge-and-check:
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: rocm-gfx*
+          path: dist/parts
+      - name: micromamba
+        run: |
+          mkdir -p ~/.mm && curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xj -C ~/.mm bin/micromamba
+          { echo "MAMBA_EXE=$HOME/.mm/bin/micromamba"; echo "MAMBA_ROOT_PREFIX=$HOME/micromamba"
+            echo "GRACE_CACHE=$HOME/grace-cache"; } >> "$GITHUB_ENV"
+      - name: merge (one wheel per CPython tag with all modules)
+        run: |
+          "$MAMBA_EXE" create -y -q -n gn-rocmchk -c conda-forge python=3.12 pip numpy ase tqdm pytest auditwheel binutils
+          "$MAMBA_ROOT_PREFIX/envs/gn-rocmchk/bin/python" scripts/merge_cuda_wheels.py dist/rocm-wheelhouse dist/parts/rocm-gfx*/*.whl
+          cp "$(find dist/parts -name '*.tar.gz' | head -1)" dist/rocm-wheelhouse/
+          ls -la dist/rocm-wheelhouse
+      - name: check the wheels' contents
+        run: |
+          for w in dist/rocm-wheelhouse/*.whl; do
+            "$MAMBA_ROOT_PREFIX/envs/gn-rocmchk/bin/python" scripts/check_rocm_wheel.py "$w" "${{ join(fromJSON(inputs.archs), ',') }}"
+          done
+      - name: without a GPU, device="auto" runs on the CPU (no warning)
+        run: |
+          PYTHONS=3.12 bash scripts/build_wheels.sh dist/wheelhouse    # the CPU package it plugs into
+          P=$MAMBA_ROOT_PREFIX/envs/gn-rocmchk/bin
+          "$P/python" -m pip install -q dist/wheelhouse/*cp312-abi3*.whl dist/rocm-wheelhouse/*cp312-abi3*.whl
+          "$P/grace-runtime" models download GRACE-1L-OMAT-large-base
+          "$P/python" -m pytest -q -p no:cacheprovider python/tests/test_rocm_plugin.py
+          cd /tmp && "$P/python" -W error::RuntimeWarning - <<'PY'
+          import os, grace_runtime, grace_runtime._rocm as r
+          print("plug-ins:", [p.__name__ for p in r.plugins()], "modules:", r.available())
+          assert "grace_runtime_rocm6" in [p.__name__ for p in r.plugins()]
+          os.environ.pop("GRACE_RUNTIME_DEVICE", None)
+          calc = grace_runtime.GRACERuntimeCalculator("GRACE-1L-OMAT-large-base")
+          assert calc.backend == "cpu", calc.backend
+          print("no GPU: device='auto' ->", calc.backend)
+          try:
+              grace_runtime.GRACERuntimeCalculator("GRACE-1L-OMAT-large-base", device="rocm")
+              raise SystemExit("device='rocm' without a GPU did not fail")
+          except ImportError as e:
+              print("no GPU: device='rocm' ->", type(e).__name__, e)
+          PY
+      - uses: actions/upload-artifact@v4
+        with:
+          name: rocm-wheels
+          path: |
+            dist/rocm-wheelhouse/*.whl
+            dist/rocm-wheelhouse/*.tar.gz
+          if-no-files-found: error

grace_runtime-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+build*/
+__pycache__/
+*.npz
+!tests/fixtures/*.npz
+Testing/
+python/build/
+*.egg-info/
+*.so
+dist/
+.micromamba/
+.mm/
+.grace-cache/
+.worktrees/

grace_runtime-0.1.0/.readthedocs.yaml

@@ -0,0 +1,16 @@
+# Read the Docs configuration file
+# https://docs.readthedocs.io/en/stable/config-file/v2.html
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.13"
+
+mkdocs:
+  configuration: mkdocs.yml
+  fail_on_warning: true
+
+python:
+  install:
+    - requirements: docs/requirements.txt

grace_runtime-0.1.0/CHANGELOG.md

@@ -0,0 +1,150 @@
+# Changelog
+
+Notable changes of grace-runtime, grace-runtime-cuda12 and grace-runtime-rocm6 (they share one version). Each
+release has a section "Changed defaults" when a default behaves differently.
+
+## [0.1.0](https://github.com/ICAMS/grace-runtime/releases/tag/0.1.0) (2026-10-29)
+
+First release on PyPI: `grace-runtime` (CPU), `grace-runtime-cuda12` (NVIDIA) and `grace-runtime-rocm6` (AMD). It
+contains everything of the 0.0.1.dev1 rehearsal below, and the changes listed here.
+
+### Added
+
+- **PACE models** (pacemaker's ACE potentials): energies, forces, stress and the extrapolation grade gamma on the CPU,
+  NVIDIA and AMD GPUs. `Model` reads the B-basis `.yaml` (and the active set `.asi`) directly. In LAMMPS the style
+  `pace/runtime(/kk)` runs them; on GPUs it is 1.3x to 3.0x faster than `pace/kk`, both in double precision.
+- **macOS arm64 wheels** (Apple Silicon, macOS 11 and later).
+- **LAMMPS**: one style `grace/runtime(/kk)` for GRACE-1L, 2L and 3L models. It reads the model kind from the file.
+  A keyword that does not fit the model is an error; a keyword of the other backend (CPU or Kokkos) gives a warning.
+  A repeated `pair_style` rebuilds the engine from the loaded model.
+- grace-runtime reads the model kind and format version that newer tensorpotential exports write into `kokkos.npz`.
+  Older exports still load; a file from a newer exporter stops with a clear message.
+- `Model(store_max_gb=)`, `Model.store_max_gb` and `backend_info["store"]`: the memory budget of the forward store,
+  with a `RuntimeWarning` when the store does not fit and the backward pass recomputes it.
+- `Model.compute(positions=, image=, shifts=)` and `NeighborList.image` / `.shifts`: the CPU engines form the bond
+  vectors from the positions and a shift index per bond (PACE, 32768 carbon atoms, 20 threads: 16 % faster per step).
+- The documentation site with an API reference.
+
+### Changed
+
+- NVIDIA without the `[cublas]` extra: GRACE-3L takes 0-15 % longer than with cuBLAS (0.0.1.dev1: up to 16x), with
+  the same results within fp32 rounding. The extra stays optional.
+- The neighbour list keeps 8 bytes per bond instead of 40.
+- `energy_only=True` calls on the CPU skip the derivative work and its buffers (GRACE-1L/2L/3L and D3), and GRACE-3L
+  UQ projects all atoms of a block in one matrix product.
+- A GPU calculation that runs out of memory retries with smaller chunks, also when a kernel launch fails.
+- More input checks: atomic numbers, property ranges (`eos_batch`, `elastic_batch`), nearly flat cells, two atoms at
+  the same position (an error).
+
+### Changed defaults
+
+- `GRACERuntimeCalculator(energy_only=False)`: the first request computes energy, forces and stress together, and
+  later requests on the same atoms reuse them. Pass `energy_only=True` for energy-only screening.
+- The forward store (GRACE-2L layer 1, GRACE-3L layers 1-2) follows the available memory per process, in Python and in
+  LAMMPS; above it the backward pass recomputes the layers. Before: GRACE-2L a fixed 8 GB, GRACE-3L no limit.
+- The automatic memory budgets (forward store, GRACE-3L radial tables) follow a cgroup memory limit (Slurm `--mem`,
+  containers) when there is one, instead of the memory of the node.
+- NVIDIA without cuBLAS: the built-in Kokkos GEMMs run (`blas()` reports `kkgemm`); `GRACE_RUNTIME_NO_KKGEMM=1` brings
+  back the earlier kernels. Without the `[cublas]` extra a system cuBLAS 12 is used when found; one older than 12.0
+  (12.8 on compute capability 10 and above) is skipped with a warning.
+- The automatic GPU chunk size goes down to 512 atoms when memory is short (before: 1024).
+- C++ builds of libgrace and its tests with CMake: `GRACE_ARCH_FLAGS` defaults to `-march=native`. The Python
+  package, the wheels and LAMMPS are not affected.
+
+### Removed
+
+- LAMMPS styles `grace/{1l,2l,3l}/fused(/kk)`: use `grace/runtime(/kk)`.
+  The TensorFlow styles `grace/1layer/chunk`, `grace/2layer/chunk` and `grace/2layer/parallel`: use `grace/runtime`
+  with a `kokkos.npz` export. `pair_style grace` (TensorFlow) and `grace/fs(/kk)` stay.
+- LAMMPS `pace/kk/fp64` (`/device`, `/host`): `pace/kk` runs in double precision again. On GPUs with slow double
+  precision it is about 2x slower than its earlier mixed-precision default, which failed the accuracy tests.
+
+### Fixed
+
+- Systems above about 33 million atoms on large GPUs (64-bit offsets of the neighbour and bond lists).
+- A GPU batch is usable again after an allocation failure.
+- GRACE-3L on the GPU after a re-setup with other radial-table settings.
+- Open cell directions that are not orthogonal to the periodic ones.
+- AMD RDNA (32-lane) GPUs in the GRACE-2L backward kernel.
+- `free_gpu_memory()` also releases calculators that only a reference cycle keeps alive, and their GPU models.
+- GRACE-3L on the CPU ignored `num_threads` in some loops when `OMP_NUM_THREADS` was larger.
+- `grace-runtime info` with no visible CUDA device.
+- The rocm6 wheels claimed manylinux2014 but need glibc 2.28: they are tagged `manylinux_2_28` now.
+- LAMMPS: `comm_style tiled` with the Kokkos GRACE-2L style gave wrong forces and GRACE-3L stopped; `fix pair` UQ on
+  empty CPU ranks; `pace/kk` and `pace/extrapolation/kk` stopped on the GPU for multi-element files without pair
+  blocks.
+
+### Known issues
+
+- LAMMPS `fix atom/swap` with Kokkos pair styles (also `lj/cut/kk`) makes other swap decisions than on the CPU.
+- LAMMPS `pair_style grace` (TensorFlow) with a two-layer model gives wrong results on more than one MPI rank: use
+  `grace/runtime`.
+
+## [0.0.1.dev1](https://github.com/ICAMS/grace-runtime/releases/tag/0.0.1.dev1) (2026-10-26)
+
+Pre-release on TestPyPI only: the second rehearsal of the release pipeline, now with the GPU packages
+`grace-runtime-cuda12` (NVIDIA, CUDA 12) and `grace-runtime-rocm6` (AMD, ROCm 6). The GPU packages pin the same
+version of `grace-runtime`: their interface to the CPU package changed in this release.
+
+### Added
+
+- **AMD GPUs** (HIP / ROCm 6): the fused GRACE-1L / 2L / 3L engines on MI210 / MI250 / MI250X (gfx90a) and
+  MI300A / MI300X (gfx942), in the Python package (`device="rocm"`, `"rocm:N"`) and in the LAMMPS styles
+  `grace/{1l,2l,3l}/fused/kk`. Package `grace-runtime-rocm6`.
+- **Batched relaxation**: `relax_batch` and `relax_batch_iter` relax many structures in one GPU batch (FIRE as in
+  ASE; optional cell relaxation as `ase.filters.FrechetCellFilter`, pressure, fixed atoms, `fix_symmetry`).
+  Structures that converge leave the batch and waiting ones take their place. Command line:
+  `grace-runtime relax MODEL IN -o OUT`. `compute_batch_iter` evaluates a stream of structures.
+- **Properties in batches**: `eos_batch` (equation of state), `elastic_batch` (elastic constants, stress method),
+  `phonons_batch` and `phonopy_forces_batch` (phonopy).
+- **Dispersion correction DFT-D3(BJ)**, optionally with the Axilrod-Teller-Muto three-body term, on the CPU, CUDA and
+  HIP: argument `dispersion=` of the calculator, `compute_batch`, the relaxation and property functions and the
+  TorchSim model, as a short form (`"d3-pbe"`, `"d3-r2scan"`, `"d3-pbe-atm"`) or `D3(...)`. Off unless given.
+- `Model` takes a registry name or a `pathlib.Path`; one loaded `Model` can be passed to all functions.
+- CPU kernels for Apple Silicon (NEON, Accelerate); source builds on macOS with Homebrew or conda OpenMP.
+- Example notebook with ASE: energies, relaxations, EOS, elastic constants, UQ, MD.
+
+### Changed
+
+- Faster GPU kernels: CUDA bond kernels for GRACE-1L / 2L (A100 2L 4-16 % faster), GRACE-2L / 3L kernels on CUDA,
+  matrix-core kernels on AMD GPUs.
+- The GPU calculator builds no CPU neighbour list.
+- GPU per-atom energies: the last step (scale and shift) runs in fp64, as on the CPU; GRACE-1L sums one of its
+  intermediate terms in fp64. GPU results change at the level of fp32 rounding (GRACE-1L on strongly compressed
+  cells: up to about 1e-4 eV per atom).
+- The engine self-tests compare with the fp32 rounding bound: models whose first-layer outputs cancel, which the GPU
+  refused before, now run there.
+- A `Model` loaded with a `spline` other than 1024 uses it on the GPU too (before: always 1024).
+- New errors for inputs that were accepted before: a negative, NaN or infinite `skin`; `GRACE_RUNTIME_STRICT=1` with
+  `device="auto"` on a machine without a usable GPU; a malformed `kokkos.npz` (each array is checked against the
+  model's own sizes, with a message that names the array).
+
+### Changed defaults
+
+- GPU `compute_batch` and the TorchSim model build their neighbour lists on the GPU (before: on the host);
+  `num_threads` applies to their CPU paths only.
+- CUDA: GRACE-1L / 2L use the GPU bond kernels (no switch).
+- AMD gfx90a (MI250X): the matrix-core kernels are on by default (`GRACE_FUSED_MFMA=0` turns them off); on gfx94x they
+  are opt-in. The GRACE-3L FC fold (`fc_fold = 1`) takes effect on AMD GPUs too.
+- macOS source builds: `GRACE_RUNTIME_ISAS=native`; GRACE-3L CPU matrix products through Accelerate.
+
+### Removed
+
+- The matscipy neighbour list backend (`neighbor_backend="matscipy"`) and the `matscipy` extra; the built-in list is
+  the only one.
+
+### Fixed
+
+- A failed GPU kernel launch stops the run instead of returning wrong results.
+- `free_gpu_memory()` frees every per-atom GPU buffer, also those of the GRACE-3L matrix-core kernels.
+- A forced older GPU module (PTX) needs a driver for CUDA 12.9 or newer; this is checked.
+- GRACE-1L on Turing GPUs (RTX 20xx, T4): kernel launch bounds.
+- Runs with no central atoms (empty MPI ranks): neighbour count and UQ.
+- GPU bond compaction with atoms of unmapped elements.
+- `GRACE_RUNTIME_ROCM_ARCH` works when the architecture cannot be read from the PCI bus.
+- Build warnings with GCC 16.
+
+## [0.0.1.dev0](https://github.com/ICAMS/grace-runtime/releases/tag/0.0.1.dev0) (2026-10-20)
+
+Pre-release on TestPyPI only, to test the release pipeline: the CPU package `grace-runtime` (manylinux2014 x86_64
+wheels for CPython 3.10, 3.11 and >= 3.12, with x86-64-v3 and x86-64-v4 builds).