diff --git a/.github/workflows/wheel.yml b/.github/workflows/wheel.yml
index 0fd6174..9e82f58 100644
--- a/.github/workflows/wheel.yml
+++ b/.github/workflows/wheel.yml
@@ -12,13 +12,15 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
-    container: python:${{ matrix.python-version }}-bullseye
+    container: python:${{ matrix.python-version }}${{ matrix.image-suffix }}-bullseye
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
-    
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+        include:
+          - python-version: '3.13'
+            image-suffix: '-rc'
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Build
       shell: bash
       run: |
@@ -27,33 +29,36 @@ jobs:
         python -m pip install -U pip build
         python -m build .
     - name: Upload Wheel
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: py_build_cmake-whl-${{ matrix.python-version }}
         path: dist/py_build_cmake-*.whl
     - name: Upload source
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: py_build_cmake-src-${{ matrix.python-version }}
-        path: dist/py-build-cmake-*.tar.gz
+        path: dist/py_build_cmake-*.tar.gz
 
   test:
     needs: build
     runs-on: ubuntu-latest
-    container: python:${{ matrix.python-version }}-bullseye
+    container: python:${{ matrix.python-version }}${{ matrix.image-suffix }}-bullseye
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+        include:
+          - python-version: '3.13'
+            image-suffix: '-rc'
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/download-artifact@v3
+    - uses: actions/checkout@v4
+    - uses: actions/download-artifact@v4
       with:
         name: py_build_cmake-whl-${{ matrix.python-version }}
         path: dist
     - name: Run Nox
       run: |
-        python -m pip install -U pip nox
-        python -m nox
+        python -m pip install -U pip nox distlib jinja2
+        python -m nox --force-color
       env:
         PY_BUILD_CMAKE_WHEEL_DIR: ${{ github.workspace }}/dist
 
@@ -61,14 +66,14 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
-
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
       name: Install Python
-      with: 
+      with:
         python-version: ${{ matrix.python-version }}
+        allow-prereleases: true
     - name: Build
       shell: powershell
       run: |
@@ -79,51 +84,51 @@ jobs:
       env:
         PYTHONUTF8: 1
     - name: Upload Wheel
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: py_build_cmake-whl-win-${{ matrix.python-version }}
         path: dist/py_build_cmake-*.whl
-    - name: Upload source
-      uses: actions/upload-artifact@v3
-      with:
-        name: py_build_cmake-src-${{ matrix.python-version }}
-        path: dist/py-build-cmake-*.tar.gz
 
   test-windows:
     needs: build-windows
     runs-on: windows-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
       name: Install Python
-      with: 
+      with:
         python-version: ${{ matrix.python-version }}
-    - uses: actions/download-artifact@v3
+        allow-prereleases: true
+    - uses: actions/download-artifact@v4
       with:
         name: py_build_cmake-whl-win-${{ matrix.python-version }}
         path: dist
     - name: Run Nox
       run: |
-        python -m pip install -U pip nox
-        python -m nox
+        python -m pip install -U pip nox distlib jinja2
+        python -m nox --force-color
       env:
         PY_BUILD_CMAKE_WHEEL_DIR: ${{ github.workspace }}/dist
 
   build-macos:
-    runs-on: macos-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
-
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+        os: ['macos-13', 'macos-latest']
+        exclude:
+          - python-version: '3.7'
+            os: 'macos-latest'
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
       name: Install Python
-      with: 
+      with:
         python-version: ${{ matrix.python-version }}
+        allow-prereleases: true
     - name: Build
       run: |
         python -m venv py-venv
@@ -131,50 +136,81 @@ jobs:
         python -m pip install -U pip build
         python -m build .
     - name: Upload Wheel
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
-        name: py_build_cmake-whl-mac-${{ matrix.python-version }}
+        name: py_build_cmake-whl-${{ matrix.os }}-${{ matrix.python-version }}
         path: dist/py_build_cmake-*.whl
-    - name: Upload source
-      uses: actions/upload-artifact@v3
-      with:
-        name: py_build_cmake-src-${{ matrix.python-version }}
-        path: dist/py-build-cmake-*.tar.gz
 
   test-macos:
     needs: build-macos
-    runs-on: macos-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+        os: ['macos-13', 'macos-latest']
+        exclude:
+          - python-version: '3.7'
+            os: 'macos-latest'
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
       name: Install Python
-      with: 
+      with:
         python-version: ${{ matrix.python-version }}
-    - uses: actions/download-artifact@v3
+        allow-prereleases: true
+    - uses: actions/download-artifact@v4
       with:
-        name: py_build_cmake-whl-mac-${{ matrix.python-version }}
+        name: py_build_cmake-whl-${{ matrix.os }}-${{ matrix.python-version }}
         path: dist
     - name: Run Nox
       run: |
-        python -m pip install -U pip nox
-        python -m nox
+        python -m pip install -U pip nox distlib jinja2
+        python -m nox --force-color
       env:
         PY_BUILD_CMAKE_WHEEL_DIR: ${{ github.workspace }}/dist
 
-  release:
+  cibw:
+    needs: [build]
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-20.04, windows-2019, macos-13, macos-latest]
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/download-artifact@v4
+      with:
+        name: py_build_cmake-whl-3.11
+        path: dist
+    - name: Build Wheels
+      uses: pypa/cibuildwheel@7940a4c0e76eb2030e473a5f864f291f63ee879b
+      with:
+        package-dir: examples/pybind11-project
+        output-dir: dist
+      env:
+        CIBW_ARCHS_LINUX: 'x86_64 i686'
+        CIBW_ARCHS_WINDOWS: 'AMD64 x86 ARM64'
+        CIBW_ARCHS_MACOS: 'x86_64 universal2 arm64'
+        CIBW_BUILD: 'cp311-* pp39-*'
+        CIBW_ENVIRONMENT: 'PIP_FIND_LINKS=${{ github.workspace }}/dist PY_BUILD_CMAKE_VERBOSE=1'
+        CIBW_ENVIRONMENT_LINUX: 'PIP_FIND_LINKS=/project/dist PY_BUILD_CMAKE_VERBOSE=1'
+        CIBW_ENVIRONMENT_WINDOWS: 'PIP_FIND_LINKS=D:/a/py-build-cmake/py-build-cmake/dist PY_BUILD_CMAKE_VERBOSE=1'
+    - name: Upload Wheels
+      uses: actions/upload-artifact@v4
+      with:
+        name: pybind11_project-${{ matrix.os }}-whl
+        path: dist/*.whl
+
+  check-release:
     if: ${{ github.event.action == 'released' || github.event.action == 'prereleased' }}
-    needs: [test, test-windows, test-macos]
+    needs: [test, test-windows, test-macos, cibw]
     runs-on: ubuntu-latest
     container: python:${{ matrix.python-version }}-bullseye
     strategy:
       matrix:
-        python-version: ['3.10']
+        python-version: ['3.11']
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/download-artifact@v3
+    - uses: actions/checkout@v4
+    - uses: actions/download-artifact@v4
       with:
         name: py_build_cmake-whl-${{ matrix.python-version }}
         path: dist
@@ -184,19 +220,24 @@ jobs:
       run: |
         [ "${{ github.event.release.tag_name }}" == "$(python -c 'from importlib.metadata import version as v; print(v("py_build_cmake"))')" ]
       shell: bash
-    - name: Install Twine
-      run: pip install twine
-    - name: Upload Wheel to PyPI
-      run: python -m twine upload dist/py_build_cmake-*.whl
-      env:
-        TWINE_USERNAME: __token__
-        TWINE_PASSWORD: ${{ secrets.PyPI }}
-    - uses: actions/download-artifact@v3
+
+  release:
+    needs: [check-release]
+    if: ${{ github.event.action == 'released' || github.event.action == 'prereleased' }}
+    runs-on: ubuntu-latest
+    environment:
+      name: release
+      url: https://pypi.org/p/py-build-cmake
+    permissions:
+      id-token: write  # mandatory for trusted publishing
+    steps:
+    - uses: actions/download-artifact@v4
       with:
-        name: py_build_cmake-src-${{ matrix.python-version }}
+        name: py_build_cmake-whl-3.11
         path: dist
-    - name: Upload source to PyPI
-      run: python -m twine upload dist/py-build-cmake-*.tar.gz
-      env:
-        TWINE_USERNAME: __token__
-        TWINE_PASSWORD: ${{ secrets.PyPI }}
+    - uses: actions/download-artifact@v4
+      with:
+        name: py_build_cmake-src-3.11
+        path: dist
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@15c56dba361d8335944d31a2ecd17d700fc7bcbc
diff --git a/.gitignore b/.gitignore
index 0db9073..1ad5771 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,11 @@
-py*-venv
-.venv
+/toolchains
+.venv*
 build
 .build
 .*cache
 __pycache__
 *.pyc
 dist
+dist-nox
 .nox
-old
\ No newline at end of file
+old
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..61661e1
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,48 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: "v0.3.4"
+    hooks:
+      - id: ruff
+        args: ["--fix", "--show-fixes"]
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: "24.3.0"
+    hooks:
+      - id: black
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: "v1.9.0"
+    hooks:
+      - id: mypy
+        files: ^src
+        args: []
+        additional_dependencies:
+          - "distlib~=0.3.5"
+          - "pyproject-metadata~=0.7.1"
+          - "tomli>=1.2.3,<3; python_version < '3.11'"
+          - "lark>=1.1.9,<2"
+          - "click~=8.1.3"
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: "v18.1.2"
+    hooks:
+      - id: clang-format
+        types_or: [c++, c]
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: "v4.5.0"
+    hooks:
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-shebang-scripts-are-executable
+      - id: check-symlinks
+      - id: check-toml
+      - id: check-yaml
+      - id: debug-statements
+      - id: end-of-file-fixer
+        exclude: '(^tests/expected_contents/.*\.txt$)|(^docs/(Components|Config)\.md$)'
+      - id: fix-byte-order-marker
+      - id: mixed-line-ending
+      - id: name-tests-test
+        args: ["--pytest-test-first"]
+      - id: requirements-txt-fixer
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+        exclude: '^docs/(Components|Config)\.md$'
diff --git a/.vscode/settings.json b/.vscode/settings.json
index cab54b9..917a55b 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,7 +1,7 @@
 {
-    "python.formatting.provider": "yapf",
+    "python.formatting.provider": "black",
     "python.linting.mypyEnabled": true,
     "cmake.configureEnvironment": {
         "VIRTUAL_ENV": "${workspaceFolder}/.venv"
     },
-}
\ No newline at end of file
+}
diff --git a/README.md b/README.md
index 979d5be..f7963b6 100644
--- a/README.md
+++ b/README.md
@@ -10,14 +10,14 @@ backend for creating Python packages with extensions built using CMake.
 ## Features
 
  - Building and packaging C, C++ or Fortran extension modules for Python using CMake
- - Declarative configuration using `pyproject.toml` ([PEP 621](https://www.python.org/dev/peps/pep-0621/)), compatible with
-   [flit](https://github.com/pypa/flit)
+ - Declarative configuration using `pyproject.toml` ([PEP 621](https://www.python.org/dev/peps/pep-0621/))
  - Editable/development installations for Python modules ([PEP 660](https://www.python.org/dev/peps/pep-0660/))
- - Compatible with [pybind11](https://github.com/pybind/pybind11) and [nanobind](https://github.com/wjakob/nanobind)
+ - Easy integration with [pybind11](https://github.com/pybind/pybind11) and [nanobind](https://github.com/wjakob/nanobind), with stable ABI support
  - Stub generation for type checking and autocompletion
- - Customizable CMake configuration, build and installation options
- - Support for multiple installation configurations and components
- - Cross-compilation support
+ - Customizable CMake configuration, build, and installation options
+ - Support for installation of multiple configurations and components, across different Wheel packages
+ - First-class cross-compilation support
+ - Reproducible Wheels and source distributions
  - No dependency on [setuptools](https://github.com/pypa/setuptools)
  - Compatible with [cibuildwheel](https://github.com/pypa/cibuildwheel) for building Wheels
 
@@ -34,7 +34,7 @@ pip install py-build-cmake
 
 The documentation can be found on <https://tttapa.github.io/py-build-cmake>.
 
-The format of the configuration file is explained in 
+The format of the configuration file is explained in
 [Config.md](https://tttapa.github.io/py-build-cmake/Config.html).
 
 Alternatively, use the [command-line interface](https://tttapa.github.io/py-build-cmake/CLI.html)
@@ -43,11 +43,15 @@ to get the documentation for all supported options:
 py-build-cmake config format
 ```
 
+To get started quickly, have a look at the following section and the README in
+[`examples/minimal`](https://github.com/tttapa/py-build-cmake/tree/main/examples/minimal),
+which goes over the project structure and the configuration files you'll need.
+
 ## Usage
 
 If you don't have one already, add a `pyproject.toml` configuration file to your
-project's repository. Specify the metadata required by [PEP 621](https://www.python.org/dev/peps/pep-0621/),
-and tell py-build-cmake how to build your project. For example:
+project's repository. Specify the mandatory project metadata ([PyPA: Declaring project metadata](https://packaging.python.org/en/latest/specifications/declaring-project-metadata)),
+and tell py-build-cmake how to build your CMake project. For example:
 
 ```toml
 [project] # Project metadata
@@ -63,7 +67,7 @@ dependencies = ["numpy"]
 dynamic = ["version", "description"]
 
 [build-system] # How pip and other frontends should build this project
-requires = ["py-build-cmake~=0.1.8"]
+requires = ["py-build-cmake~=0.3.0"]
 build-backend = "py_build_cmake.build"
 
 [tool.py-build-cmake.module] # Where to find the Python module to package
@@ -106,7 +110,12 @@ using a very simple Python module as an example.
 For a more advanced, real-world example, see [`examples/pybind11-project`](https://github.com/tttapa/py-build-cmake/tree/main/examples/pybind11-project)
 and [`examples/nanobind-project`](https://github.com/tttapa/py-build-cmake/tree/main/examples/nanobind-project).  
 If you are interested in packaging C/C++/Fortran programs using py-build-cmake,
-have a look at [`examples/minimal-program`](https://github.com/tttapa/py-build-cmake/tree/main/examples/minimal-program).
+have a look at [`examples/minimal-program`](https://github.com/tttapa/py-build-cmake/tree/main/examples/minimal-program).  
+See the [`examples`](https://github.com/tttapa/py-build-cmake/tree/main/examples) folder for a full list of examples.
+
+A full example that uses the Conan package manager for C++ dependencies, and
+that uses GitHub Actions to deploy the Wheel packages built by py-build-cmake
+to PyPI can be found in [tttapa/py-build-cmake-example](https://github.com/tttapa/py-build-cmake-example).
 
 ## Projects using py-build-cmake
 
@@ -116,9 +125,17 @@ py-build-cmake as their Python build backend:
 - [alpaqa](https://github.com/kul-optec/alpaqa/tree/develop)
 - [QPALM](https://github.com/kul-optec/QPALM)
 
+## Alternatives and related tools
+
+- [scikit-build-core](https://github.com/scikit-build/scikit-build-core): alternative CMake build backend, successor of [scikit-build](https://github.com/scikit-build/scikit-build)
+- [meson-python](https://github.com/mesonbuild/meson-python): Meson build backend
+- [flit](https://github.com/pypa/flit): pure-Python packaging tool and build backend
+- [hatchling](https://hatch.pypa.io/latest/config/build/#build-system): build backend of the [Hatch](https://hatch.pypa.io/latest/) project manager, supports build hooks
+- [poetry-core](https://python-poetry.org/docs/pyproject/#poetry-and-pep-517): pure-Python build backend for the [Poetry](https://python-poetry.org/) package manager
+- [crossenv](https://github.com/benfogle/crossenv): tool to trick `setuptools` into cross-compiling by monkey patching the `sysconfig` and `distutils` modules
+
 ## Planned features
 
  - [x] ~~macOS support~~
  - [x] ~~Entry point support~~
- - [ ] Namespace package support ([PEP 420](https://www.python.org/dev/peps/pep-0420/))
- - [ ] Doxygen and Sphinx support
+ - [x] ~~Namespace package support ([PEP 420](https://www.python.org/dev/peps/pep-0420/))~~
diff --git a/docs/Components.md b/docs/Components.md
index a42c4f5..05817cf 100644
--- a/docs/Components.md
+++ b/docs/Components.md
@@ -7,17 +7,17 @@ A possible use case is distributing debug symbols: these files can be large, and
 
 See [examples/minimal-debug-component](https://github.com/tttapa/py-build-cmake/tree/main/examples/minimal-debug-component) for more information.
 
+The most important option is `main_project`, which is a relative path that points to the directory containing the`pyproject.toml` of the main package (where all CMake options are defined). Next, the options in the `component` section define which CMake projects and components should be installed in this component package.
+
 ## component
 Options for a separately packaged component. 
 
 | Option | Description | Type | Default |
 |--------|-------------|------|---------|
-| `main_project` | Directory containing the main pyproject.toml file.<br/>Relative to project directory. | path | `'..'` |
 | `build_presets` | CMake presets to use for building. Passed as `--preset <?>` during the build phase, once for each preset. | list | `none` |
-| `install_presets` | CMake presets to use for installing. Passed as `--preset <?>` during the installation phase, once for each preset. | list | `build_presets` |
-| `build_args` | Extra arguments passed to the build step.<br/>For example: `build_args = ["-j", "--target", "foo"]` | list | `none` |
-| `build_tool_args` | Extra arguments passed to the build tool in the build step (e.g. to Make or Ninja).<br/>For example: `build_tool_args = ["--verbose", "-d", "explain"]` | list | `none` |
+| `build_args` | Extra arguments passed to the build step.<br/>For example: `build_args = ["-j", "--target", "foo"]` | list+ | `none` |
+| `build_tool_args` | Extra arguments passed to the build tool in the build step (e.g. to Make or Ninja).<br/>For example: `build_tool_args = ["--verbose", "-d", "explain"]` | list+ | `none` |
 | `install_only` | Do not build the project, only install it.<br/>For example: `install_only = true` | bool | `false` |
-| `install_args` | Extra arguments passed to the install step.<br/>For example: `install_args = ["--strip"]` | list | `none` |
+| `install_args` | Extra arguments passed to the install step.<br/>For example: `install_args = ["--strip"]` | list+ | `none` |
 | `install_components` | List of components to install, the install step is executed once for each component, with the option `--component <?>`. | list | `required` |
 
diff --git a/docs/Config.md b/docs/Config.md
index cd9ea04..f8b62f9 100644
--- a/docs/Config.md
+++ b/docs/Config.md
@@ -11,13 +11,16 @@ Defines the import name of the module or package, and the directory where it can
 |--------|-------------|------|---------|
 | `name` | Import name in Python (can be different from the name on PyPI, which is defined in the [project] section). | string | `/pyproject.toml/project/name` |
 | `directory` | Directory containing the Python module/package.<br/>Relative to project directory. | path | `'.'` |
+| `namespace` | Set to true for PEP 420 namespace packages. | bool | `false` |
+| `generated` | Do not try to locate the main module in the source directory, but assume that it is generated by CMake. Dynamic metadata cannot be used when set. | `'module'` \| `'package'` | `none` |
 
 ## editable
 Defines how to perform an editable install (PEP 660). See https://tttapa.github.io/py-build-cmake/Editable-install.html for more information. 
 
 | Option | Description | Type | Default |
 |--------|-------------|------|---------|
-| `mode` | Mechanism to use for editable installations. Either write a wrapper \_\_init\_\_.py file, install an import hook, or install symlinks to the original files. | `'wrapper'` \| `'hook'` \| `'symlink'` | `'wrapper'` |
+| `mode` | Mechanism to use for editable installations. Either write a wrapper \_\_init\_\_.py file, install an import hook, or install symlinks to the original files. | `'wrapper'` \| `'hook'` \| `'symlink'` | `'symlink'` |
+| `build_hook` | Automatically re-build any changed files and C extension modules when the package is first imported by Python. It is recommended to use a fast generator like Ninja. Currently, the only mode that supports build hooks is `symlink`. | bool | `false` |
 
 ## sdist
 Specifies the files that should be included in the source distribution for this package. 
@@ -32,25 +35,38 @@ Defines how to build the project to package. If omitted, py-build-cmake will pro
 
 | Option | Description | Type | Default |
 |--------|-------------|------|---------|
-| `minimum_version` | Minimum required CMake version. If this version is not available in the system PATH, it will be installed automatically as a build dependency.<br/>For example: `minimum_version = "3.18"` | string | `none` |
+| `minimum_version` | Minimum required CMake version. Used for policies in the automatically generated CMake cache pre-load files. If this version is not available in the system PATH, it will be installed automatically as a build dependency (using Pip).<br/>For example: `minimum_version = "3.18"` | string | `'3.15'` |
 | `build_type` | Build type passed to the configuration step, as `-DCMAKE_BUILD_TYPE=<?>`.<br/>For example: `build_type = "RelWithDebInfo"` | string | `none` |
-| `config` | Configuration type passed to the build and install steps, as `--config <?>`. You can specify either a single string, or a list of strings. If a multi-config generator is used, all configurations in this list will be included in the package.<br/>For example: `config = ["Debug", "Release"]` | list | `build_type` |
+| `config` | Configuration type passed to the build step, as `--config <?>`. You can specify either a single string, or a list of strings. If a multi-config generator is used, all configurations in this list will be built.<br/>For example: `config = ["Debug", "Release"]` | list | `build_type` |
 | `preset` | CMake preset to use for configuration. Passed as `--preset <?>` during the configuration phase. | string | `none` |
-| `build_presets` | CMake presets to use for building. Passed as `--preset <?>` during the build phase, once for each preset. | list | `preset` |
-| `install_presets` | CMake presets to use for installing. Passed as `--preset <?>` during the installation phase, once for each preset. | list | `build_presets` |
+| `build_presets` | CMake presets to use for building. Passed as `--preset <?>` during the build phase, once for each preset. | list | `none` |
 | `generator` | CMake generator to use, passed to the configuration step, as `-G <?>`. If Ninja is used, and if it is not available in the system PATH, it will be installed automatically as a build dependency.<br/>For example: `generator = "Ninja Multi-Config"` | string | `none` |
 | `source_path` | Folder containing CMakeLists.txt.<br/>Relative to project directory. | path | `'.'` |
-| `build_path` | CMake build and cache folder.<br/>Absolute or relative to project directory. | path | `'.py-build-cmake_cache'` |
-| `options` | Extra options passed to the configuration step, as `-D<option>=<value>`.<br/>For example: `options = {"WITH_FEATURE_X" = "On"}` | dict | `{}` |
-| `args` | Extra arguments passed to the configuration step.<br/>For example: `args = ["--debug-find", "-Wdev"]` | list | `[]` |
-| `find_python` | Specify hints for CMake&#x27;s FindPython module.<br/>For example: `find_python = true` | bool | `false` |
+| `build_path` | CMake build and cache folder. The placeholder `{build_config}` can be used to insert the name of the Python version and ABI, operating system, and architecture. This ensures that separate build directories are used for different host systems and Python versions/implementations.<br/>Absolute or relative to project directory. | path | `'.py-build-cmake_cache/{build_config}'` |
+| `options` | Extra options passed to the configuration step, as `-D<option>=<value>`.<br/>For example: `options = {"WITH_FEATURE_X" = true}` | dict (CMake) | `{}` |
+| `args` | Extra arguments passed to the configuration step.<br/>For example: `args = ["--debug-find", "-Wdev"]` | list+ | `[]` |
+| `find_python` | Specify hints for CMake&#x27;s FindPython module.<br/>For example: `find_python = false` | bool | `true` |
 | `find_python3` | Specify hints for CMake&#x27;s FindPython3 module.<br/>For example: `find_python3 = false` | bool | `true` |
-| `build_args` | Extra arguments passed to the build step.<br/>For example: `build_args = ["-j", "--target", "foo"]` | list | `[]` |
-| `build_tool_args` | Extra arguments passed to the build tool in the build step (e.g. to Make or Ninja).<br/>For example: `build_tool_args = ["--verbose", "-d", "explain"]` | list | `[]` |
-| `install_args` | Extra arguments passed to the install step.<br/>For example: `install_args = ["--strip"]` | list | `[]` |
+| `build_args` | Extra arguments passed to the build step.<br/>For example: `build_args = ["-j", "--target", "foo"]` | list+ | `[]` |
+| `build_tool_args` | Extra arguments passed to the build tool in the build step (e.g. to Make or Ninja).<br/>For example: `build_tool_args = ["--verbose", "-d", "explain"]` | list+ | `[]` |
+| `install_config` | Configuration types passed to the install step, as `--config <?>`. You can specify either a single string, or a list of strings. If a multi-config generator is used, all configurations in this list will be included in the package.<br/>For example: `install_config = ["Debug", "Release"]` | list | `config` |
+| `install_args` | Extra arguments passed to the install step.<br/>For example: `install_args = ["--strip"]` | list+ | `[]` |
 | `install_components` | List of components to install, the install step is executed once for each component, with the option `--component <?>`.<br/>Use an empty string to specify the default component. | list | `['']` |
 | `env` | Environment variables to set when running CMake. Supports variable expansion using `${VAR}` (but not `$VAR`).<br/>For example: `env = { "CMAKE_PREFIX_PATH" = "${HOME}/.local" }` | dict | `{}` |
 
+## wheel
+Defines how to create the Wheel package. 
+
+| Option | Description | Type | Default |
+|--------|-------------|------|---------|
+| `pure_python` | Indicate that this package contains no platform-specific binaries, only Python scripts and other platform-agnostic files. Setting this value to true causes the Wheel tags to be set to `py3-none-any`, and selects the `purelib` folder instead of `platlib`.<br/>If unset, the value depends on whether the `cmake` option is set.<br/>For example: `pure_python = true` | bool | `none` |
+| `python_tag` | Override the default Python tag for the Wheel package.<br/>If your package contains any Python extension modules, you want to set this to `auto`.<br/>For details about platform compatibility tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags<br/>For example: `python_tag = ['py2', 'py3']` | list | `'auto'` |
+| `python_abi` | Override the default ABI tag for the Wheel package.<br/>For packages with a Python extension module that make use of the full Python C API, this option should be set to `auto`.<br/>If your package does not contain Python extension modules (e.g. because it only includes executables to run as a subprocess, or only shared library files to be loaded using `ctypes`), you can set this to `none`.<br/>If your package only includes Python extension modules that use the CPython stable ABI, set this to `abi3` (see also `abi3_minimum_cpython_version` below).<br/>For details about platform compatibility tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags<br/>For example: `python_abi = 'none'` | `'auto'` \| `'none'` \| `'abi3'` | `'auto'` |
+| `abi3_minimum_cpython_version` | If `python_abi` is set to `abi3`, only use the stable CPython API for CPython version that are newer than `abi3_minimum_version`. Useful for nanobind, which supports the stable ABI for CPython 12 and later.<br/>The Python version is encoded as a single integer, consisting of the major and minor version numbers, without a dot.<br/>For example: `abi3_minimum_cpython_version = 312` | int | `32` |
+| `abi_tag` | Override the default ABI tag for the Wheel package.<br/>It is not recommended to set this value in your pyproject.toml file directly. Instead, it is intended to be specified from the command line, or in a local override. See also: cross.abi.<br/>For details about platform compatibility tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags<br/>For example: `abi_tag = 'pypy310_pp73'` | list | `none` |
+| `platform_tag` | Override the default platform tag for the Wheel package.<br/>The special value `guess` tries to select a sensible value based on the environment and the current Python interpreter (not supported when cross-compiling).<br/>It is not recommended to set this value in your pyproject.toml file directly. Instead, it is intended to be specified from the command line, or in a local override. See also: cross.arch.<br/>There are no checks in place to ensure that the platform tag applies to all files in the Wheel. If possible, you should use a tool such as auditwheel (https://github.com/pypa/auditwheel) or delocate (https://github.com/matthew-brett/delocate) to select the tag and to verify/fix the resulting package.<br/>For details about platform compatibility tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags<br/>For example: `platform_tag = 'manylinux_2_35_x86_64'` | list | `none` |
+| `build_tag` | Add an optional build number to the Wheel package. Must start with a number and cannot contain `-` characters.<br/>It is not recommended to set this value in your pyproject.toml file directly. Instead, it is intended to be specified from the command line, or in a local override.<br/>For details about Wheel build tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/binary-distribution-format/#file-name-convention<br/>For example: `build_tag = '1'` | string | `none` |
+
 ## stubgen
 If specified, mypy&#x27;s stubgen utility will be used to generate typed stubs for the Python files in the package. 
 
@@ -59,7 +75,7 @@ If specified, mypy&#x27;s stubgen utility will be used to generate typed stubs f
 | `packages` | List of packages to generate stubs for, passed to stubgen as -p &lt;?&gt;. | list | `none` |
 | `modules` | List of modules to generate stubs for, passed to stubgen as -m &lt;?&gt;. | list | `none` |
 | `files` | List of files to generate stubs for, passed to stubgen without any flags. | list | `none` |
-| `args` | List of extra arguments passed to stubgen. | list | `[]` |
+| `args` | List of extra arguments passed to stubgen. | list+ | `[]` |
 
 ## linux
 Override options for Linux. 
@@ -69,6 +85,7 @@ Override options for Linux.
 | `editable` | Linux-specific editable options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/editable` |  | `none` |
 | `sdist` | Linux-specific sdist options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/sdist` |  | `none` |
 | `cmake` | Linux-specific CMake options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/cmake` |  | `none` |
+| `wheel` | Linux-specific Wheel options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/wheel` |  | `none` |
 
 ## windows
 Override options for Windows. 
@@ -78,6 +95,7 @@ Override options for Windows.
 | `editable` | Windows-specific editable options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/editable` |  | `none` |
 | `sdist` | Windows-specific sdist options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/sdist` |  | `none` |
 | `cmake` | Windows-specific CMake options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/cmake` |  | `none` |
+| `wheel` | Windows-specific Wheel options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/wheel` |  | `none` |
 
 ## mac
 Override options for Mac. 
@@ -87,20 +105,26 @@ Override options for Mac.
 | `editable` | Mac-specific editable options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/editable` |  | `none` |
 | `sdist` | Mac-specific sdist options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/sdist` |  | `none` |
 | `cmake` | Mac-specific CMake options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/cmake` |  | `none` |
+| `wheel` | Mac-specific Wheel options.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/wheel` |  | `none` |
 
 ## cross
 Causes py-build-cmake to cross-compile the project. See https://tttapa.github.io/py-build-cmake/Cross-compilation.html for more information. 
 
 | Option | Description | Type | Default |
 |--------|-------------|------|---------|
-| `implementation` | Identifier for the Python implementation.<br/>For example: `implementation = 'cp' # CPython` | string | `same as current interpreter` |
-| `version` | Python version, major and minor, without dots.<br/>For example: `version = '310' # 3.10` | string | `same as current interpreter` |
-| `abi` | Python ABI.<br/>For example: `abi = 'cp310'` | string | `same as current interpreter` |
-| `arch` | Operating system and architecture (no dots or dashes, only underscores, all lowercase).<br/>For example: `arch = 'linux_x86_64'` | string | `same as current interpreter` |
-| `toolchain_file` | CMake toolchain file to use. See https://cmake.org/cmake/help/book/mastering-cmake/chapter/Cross%20Compiling%20With%20CMake.html for more information.<br/>Absolute or relative to current configuration file. | filepath | `required` |
-| `copy_from_native_build` | If set, this will cause a native version of the CMake project to be built and installed in a temporary directory first, and the files in this list will be copied to the final cross-compiled package. This is useful if you need binary utilities that run on the build system while cross-compiling, or for things like stubs for extension modules that cannot be generated while cross-compiling.<br/>May include the &#x27;\*&#x27; wildcard (but not &#x27;\*\*&#x27; for recursive patterns). | list | `none` |
+| `os` | Operating system configuration to inherit from. | `'linux'` \| `'mac'` \| `'windows'` | `none` |
+| `implementation` | Identifier for the Python implementation.<br/>For details about platform compatibility tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags<br/>For example: `implementation = 'cp' # CPython` | string | `same as current interpreter` |
+| `version` | Python version, major and minor, without dots.<br/>For details about platform compatibility tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags<br/>For example: `version = '310' # 3.10` | string | `same as current interpreter` |
+| `abi` | Python ABI.<br/>For details about platform compatibility tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags<br/>For example: `abi = 'cp310'` | string | `same as current interpreter` |
+| `arch` | Platform tag, consisting of the operating system and architecture (no dots or dashes, only underscores, all lowercase).<br/>For details about platform compatibility tags, see the PyPA specification: https://packaging.python.org/en/latest/specifications/platform-compatibility-tags<br/>For example: `arch = 'linux_x86_64'` | string | `same as current interpreter` |
+| `prefix` | Root path of the Python installation. Used to set the `Python3_ROOT_DIR` CMake hint, see https://cmake.org/cmake/help/latest/module/FindPython3.html#hints.<br/>Absolute or relative to current configuration file. | path | `none` |
+| `library` | Python library file (.so on Linux, .lib on Windows). Used to set the `Python3_LIBRARY` CMake artifact, see https://cmake.org/cmake/help/latest/module/FindPython3.html#artifacts-specification.<br/>Absolute or relative to current configuration file. | filepath | `none` |
+| `include_dir` | Python include directory (containing Python.h). Used to set the `Python3_INCLUDE_DIR` CMake artifact, see https://cmake.org/cmake/help/latest/module/FindPython3.html#artifacts-specification.<br/>Absolute or relative to current configuration file. | path | `none` |
+| `toolchain_file` | CMake toolchain file to use. See https://cmake.org/cmake/help/book/mastering-cmake/chapter/Cross%20Compiling%20With%20CMake.html for more information.<br/>Absolute or relative to current configuration file. | filepath | `none` |
+| `editable` | Override editable options when cross-compiling.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/editable` |  | `none` |
 | `sdist` | Override sdist options when cross-compiling.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/sdist` |  | `none` |
 | `cmake` | Override CMake options when cross-compiling.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/cmake` |  | `none` |
+| `wheel` | Override Wheel options when cross-compiling.<br/>Inherits from: `/pyproject.toml/tool/py-build-cmake/wheel` |  | `none` |
 
 # Local overrides
 
@@ -109,21 +133,98 @@ Additionally, two extra configuration files can be placed in the same directory
 - `py-build-cmake.local.toml`: the options in this file override the values in the `tool.py-build-cmake` section of `pyproject.toml`.<br/>This is useful if you need specific arguments or CMake options to compile the package on your system.
 - `py-build-cmake.cross.toml`: the options in this file override the values in the `tool.py-build-cmake.cross` section of `pyproject.toml`.<br/>Useful for cross-compiling the package without having to edit the main configuration file.
 
-# Command line overrides
+It is recommended to exclude these files from version control, e.g. by adding them to your `.gitignore`.
+
+
+# Command-line overrides
 
-Instead of using the `py-build-cmake.local.toml` and `py-build-cmake.cross.toml` files, you can also include additional config files using command line options:
+Instead of using the `py-build-cmake.local.toml` and `py-build-cmake.cross.toml` files, you can also include additional config files using command-line options:
 
 - `--local`: specifies a toml file that overrides the `tool.py-build-cmake` section of `pyproject.toml`, similar to `py-build-cmake.local.toml`
 - `--cross`: specifies a toml file that overrides the `tool.py-build-cmake.cross` section of `pyproject.toml`, similar to `py-build-cmake.cross.toml`
 
-These command line overrides are applied after the `py-build-cmake.local.toml` and `py-build-cmake.cross.toml` files in the project folder (if any).
+These command-line overrides are applied after the `py-build-cmake.local.toml` and `py-build-cmake.cross.toml` files in the project folder (if any).
 
 When using PyPA build, these flags can be specified using the `-C` or `--config-setting` flag: 
 ```sh
 python -m build . -C--cross=/path/to/my-cross-config.toml
 ```
-The same flag may appear multiple times, for example: 
+The same flag may appear multiple times. The order for the same flag is preserved, but all `--cross` flags are applied after all `--local` flags. For example: 
 ```sh
 python -m build . -C--local=conf-A.toml -C--local=conf-B.toml
 ```
-For PyPA pip, you can use the `--config-settings` flag instead.
+For PyPA pip, you can use the `-C` or `--config-settings` flags instead.
+
+Finally, you can also specify overrides for specific configuration options on the command-line, for example:
+```sh
+python -m build . \
+   -C override=cmake.options.CMAKE_PREFIX_PATH+="/opt/some-package" \
+   -C override=cmake.env.PATH=+(path)"/opt/some-package/bin"
+```
+The format consists of the configuration option keys (separated) by periods, followed by an operator (such as `+=`, see below), followed by the value.
+
+The following operators are supported:
+- `=`: Sets the configuration option regardless of its previous value.
+- `+=`: Appends the given value to the previous value.
+- `=+`: Prepends the given value to the previous value.
+- `=-`: Removes the given value from the previous value.
+- `=!`: Clears the configuration option if set.
+- `+=(path)`: Appends the given value to the previous value, joining them with the system's path separator (`:` on Unix, `;` on Windows).
+- `=+(path)`: Prepends the given value to the previous value, joining them with the system's path separator.
+
+Values can be specified using a TOML-like syntax, using square brackets for lists, and curly braces with equal signs for dictionaries. Simple strings can be specified without quotes, but quotes are required when including special characters. Note the escaping of quotes to prevent the shell from stripping them out.
+```sh
+python -m build . \
+   -C "override=cmake.options.CMAKE_PREFIX_PATH=[\"/opt/some-package\", \"/another\"]" \
+   -C "override=cmake.env={MY_PATH = \"/opt/some-package\" }" \
+   -C "override=cmake.find_python=true"
+```
+
+
+# Combining lists
+
+Many options are specified as lists of strings. When one of these options inherits from or is overridden by another option, these lists can be merged in different ways.
+
+In the table above, when the data type is `list`, the original list of options is simply replaced by the list it is overridden by.  
+When the data type is `list+`, the value of the overriding option is appended to the original value. This is used primarily for combining lists of command-line options.
+
+If you want full control of what happens when overriding a list option, you can use a dictionary with one or more of the following keys:
+
+  - `"="`: replace the original list by this list (default behavior for options of type `list`)
+  - `"+"`: append the values of this list to the end of the original list (default behavior for options of type `list+`)
+  - `"-"`: remove the values in this list from the original list (if present)
+  - `"prepend"`: prepend the values of this list to the beginning of the original list
+
+Some examples:
+
+```toml
+[cmake]
+build_args = ["--verbose", "--clean-first"]
+[linux.cmake]
+build_args = ["--target", "foo"]
+[windows.cmake]
+build_args = {"-" = ["--verbose"], "+" = ["--target", "bar"]}
+[macos.cmake]
+build_args = {"=" = ["--target", "macos"]}
+```
+Because `linux.cmake` inherits from `cmake`, and because `build_args` has type `list+`, this will result in a value of `["--verbose", "--clean-first", "--target", "foo"]` for the `linux.cmake.build_args` option. The value of `windows.cmake.build_args` will be `["--clean_first", "--target", "bar"]`, and the value of `macos.cmake.build_args` will be `["--target", "macos"]`.
+
+```toml
+[cmake]
+config = ["Debug", "Release"]
+[linux.cmake]
+config = ["RelWithDebInfo"]
+[windows.cmake]
+config = {"prepend" = ["RelWithDebInfo"], "-" = ["Debug"], "+" = ["Debug"]}
+```
+The `build_args` option has type `list`, so the value of `linux.cmake.config` is simply `["RelWithDebInfo"]`. The value of `windows.cmake.config` is `["RelWithDebInfo", "Release", "Debug"]`.
+
+The same rules also apply to CMake options:
+
+```toml
+[cmake.options]
+CMAKE_PREFIX_PATH = "/some/path"
+[linux.cmake.options]
+CMAKE_PREFIX_PATH = {"prepend" = "/some/linux-specific/path"}
+```
+This passes the option `-D CMAKE_PREFIX_PATH=/some/linux-specific/path;/some/path` to CMake.
diff --git a/docs/Cross-compilation.md b/docs/Cross-compilation.md
index 856a051..e414eac 100644
--- a/docs/Cross-compilation.md
+++ b/docs/Cross-compilation.md
@@ -2,12 +2,34 @@
 
 # Cross-compilation
 
-Cross-compiling Python extension modules is supported out of the box through 
+Cross-compiling Python extension modules is supported out of the box through
 [CMake toolchain files](https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html).
 
+When building packages using a tool like [`cibuildwheel`](https://github.com/pypa/cibuildwheel),
+cross-compilation will also be enabled automatically whenever appropriate
+(e.g. when building ARM64 packages on an Intel Mac).
+
+> Table of contents  
+> <span class="mono">¶</span>&emsp;[Terminology](#terminology)  
+> <span class="mono">¶</span>&emsp;[Simple example](#simple-example)  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Caveats](#caveats)</small>  
+> <span class="mono">¶</span>&emsp;[Complete cross-compilation workflow](#complete-cross-compilation-workflow)  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Set up the environment](#set-up-the-environment)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Download a cross-compilation toolchain for your _host_ system](#download-a-cross-compilation-toolchain-for-your-host-system)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Download Python for your _host_ system](#download-python-for-your-host-system)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Inspect and customize the toolchain files and py-build-cmake configuration](#inspect-and-customize-the-toolchain-files-and-py-build-cmake-configuration)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Cross-compile the pybind11-project example package using py-build-cmake](#cross-compile-the-pybind11-project-example-package-using-py-build-cmake)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Automated Bash scripts](#automated-bash-scripts)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[A closer look at the CMake toolchain files](#a-closer-look-at-the-cmake-toolchain-files)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Cross-compilation of dependencies](#cross-compilation-of-dependencies)</small>  
+> <span class="mono">¶</span>&emsp;[Automatic cross-compilation](#automatic-cross-compilation)  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Windows](#windows)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[macOS](#macos)</small>  
+> &emsp;<small><span class="mono">¶</span>&emsp;[Linux](#linux)</small>  
+
 ## Terminology
 
-- Build system: the system used for building, on which py-build-cmake is 
+- Build system: the system used for building, on which py-build-cmake is
   invoked.
 - Host system: the system that the compiled binaries and Python modules will be
   used on.
@@ -15,105 +37,418 @@ Cross-compiling Python extension modules is supported out of the box through
 - Native build: building on _build_ system, for the _build_ system (this is the
   usual scenario).
 
-In cross-compilation, the build and host systems are often different systems 
+In cross-compilation, the build and host systems are often different systems
 with different architectures.
 
 ## Simple example
 
-If your CMake project supports cross-compilation, cross-compiling a Python 
+If your CMake project supports cross-compilation, cross-compiling a Python
 package can be achieved by simply adding a `py-build-cmake.cross.toml` file
-to the same directory as `pyproject.toml`. This file should contain the 
-necessary information about the host system, such as the Python version, 
+to the same directory as `pyproject.toml`. This file should contain the
+necessary information about the host system, such as the Python version,
 implementation and ABI, the host operating system and architecture, and the
 relative path of the CMake toolchain file to use.
 
 For example:
 ```toml
 implementation = 'cp'  # CPython
-version = '39'         # 3.9
-abi = 'cp39'           # (default ABI for CPython 3.9)
+version = '312'        # 3.12
+abi = 'cp312'          # (default ABI for CPython 3.12)
 arch = 'linux_aarch64'
 toolchain_file = 'aarch64-linux-gnu.cmake'
+library = "/path-to-sysroot/usr/lib/aarch64-linux-gnu/libpython3.12.so"
+include_dir = "/path-to-sysroot/usr/include/python3.12"
 ```
-This will generate a package for CPython 3.9 on Linux for 64-bit ARM, using the
+This will generate a package for CPython 3.12 on Linux for 64-bit ARM, using the
 compilers defined by the toolchain file `aarch64-linux-gnu.cmake` (which you
 should provide as well).
 
-The format for the values in this file is the same as the format used for the 
-tags in wheel filenames, for example `package-1.2.3-cp39-cp39-linux_aarch64.whl`.
-
-For more information about cross-compilation, ready-to-use toolchains, and 
-example toolchain files, see <https://tttapa.github.io/Pages/Raspberry-Pi/C++-Development-Ubuntu>.
+The format for the values in this file is the same as the format used for the
+tags in wheel filenames, for example `pkg-1.2.3-cp312-cp312-linux_aarch64.whl`.
+For details about platform compatibility tags, see the PyPA specification:
+https://packaging.python.org/en/latest/specifications/platform-compatibility-tags.
 
 ### Caveats
 
 Note that `py-build-cmake` does not check the Python version when
 cross-compiling, so make sure that your CMakeLists.txt scripts find the correct
-Python installation (on that matches the version, implementation, ABI, operating
-system and architecture specified in the `py-build-cmake.cross.toml` file),
-e.g. by setting the appropriate hints and artifacts variables:
+Python installation (one that matches the version, implementation, ABI,
+operating system and architecture specified in the `py-build-cmake.cross.toml`
+file), e.g. by setting the appropriate hints and artifacts variables:
 
 - <https://cmake.org/cmake/help/latest/module/FindPython3.html#hints>
 - <https://cmake.org/cmake/help/latest/module/FindPython3.html#artifacts-specification>
 
-You can either specify these in your toolchain file, or in the
-`py-build-cmake.cross.toml` configuration, for example:
+You can either specify these in your `py-build-cmake.cross.toml` configuration
+as shown above, or in your CMake toolchain file.
+
+---
+
+## Complete cross-compilation workflow
+
+This section will guide you through the full process of cross-compiling your
+Python package.
+
+You'll need the following:
+
+- A cross-compilation toolchain that provides compilers for your _host_ system
+  (while running on your _build_ system).
+- A (pre-compiled) Python installation for the _host_ system.
+- A py-build-cmake configuration file and a CMake toolchain file with the
+  appropriate settings for your use case.
+
+Let's go over these requirements step by step:
+
+### Set up the environment
+
+We'll first clone `py-build-cmake` and its example projects:
+
+```sh
+git clone https://github.com/tttapa/py-build-cmake --branch=0.3.0
+cd py-build-cmake
+```
+
+### Download a cross-compilation toolchain for your _host_ system
+
+It is important that the toolchain has an older version of glibc and the linux
+headers, so that the resulting package is compatible with a wide range of
+Linux distributions. The toolchains in your system's package manager are usually
+not compatible with older systems.
+
+You can find ready-to-use toolchains with good compatibility at https://github.com/tttapa/toolchains.
+
+```sh
+# Create a directory to save the cross-compilation toolchains into
+mkdir -p toolchains
+# Download and extract the toolchain for AArch64 (~121 MiB)
+url="https://github.com/tttapa/toolchains/releases/download/1.0.0"
+wget "$url/x-tools-aarch64-rpi3-linux-gnu-gcc14.tar.xz" -O- | tar xJ -C toolchains
+# Verify that the toolchain works
+./toolchains/x-tools/aarch64-rpi3-linux-gnu/bin/aarch64-rpi3-linux-gnu-gcc --version
+```
+
+### Download Python for your _host_ system
+
+CMake needs to be able to locate the Python header files, and in some cases the
+Python shared library before you can build your package.
+
+You can download these from https://github.com/tttapa/python-dev.
+
+```sh
+# The toolchain is read-only by default, make it writable to add Python to it
+chmod u+w "toolchains/x-tools/aarch64-rpi3-linux-gnu"
+# Download and extract the Python binaries for AArch64 (~124 MiB)
+url="https://github.com/tttapa/python-dev/releases/download/0.0.6"
+wget "$url/python-dev-aarch64-rpi3-linux-gnu.tar.xz" -O- | tar xJ -C toolchains
+```
+
+### Inspect and customize the toolchain files and py-build-cmake configuration
+
+The Python installations from https://github.com/tttapa/python-dev already
+include the necessary CMake toolchain files and `py-build-cmake` configuration
+files. Inspect them and customize to your specific setup if necessary.
+(No changes necessary when just following this guide using the example projects).
+
+```sh
+# List the available CMake toolchain files.
+ls toolchains/x-tools/*.cmake
+# List the available py-build-cmake cross-compilation configuration files.
+ls toolchains/x-tools/*.py-build-cmake.cross.toml
+```
+
+We'll have a quick look at the `toolchains/x-tools/aarch64-rpi3-linux-gnu.python3.11.py-build-cmake.cross.toml` as an example:
 
 ```toml
+implementation = 'cp'
+version = '311'
+abi = 'cp311'
+arch = 'manylinux_2_27_aarch64'
+toolchain_file = 'aarch64-rpi3-linux-gnu.python.toolchain.cmake'
+
 [cmake.options]
-Python3_LIBRARY = "/path-to-sysroot/usr/lib/aarch64-linux-gnu/libpython3.9.so"
-Python3_INCLUDE_DIR = "/path-to-sysroot/usr/include/python3.9"
+TOOLCHAIN_PYTHON_VERSION = '3.11'
 ```
 
-You can find a full example in [examples/pybind11-project/py-build-cmake.cross.example.toml](https://github.com/tttapa/py-build-cmake/blob/main/examples/pybind11-project/py-build-cmake.cross.example.toml)
-
-## Advanced cross-builds
-
-Some projects are more difficult to cross-compile, often for one of two reasons:
-
-- The project first builds binaries that are themselves used later on in the 
-  build process to build other files.
-- Some parts of the build process require loading the previously built Python
-  modules.
-
-Since you cannot assume that the _build_ system can execute binaries for the _host_
-system, or that _build_-Python can load modules compiled for _host_-Python, the only
-solution is to build the project twice: once for the _build_ system, and once for
-the _host_ system.
-
-To get `py-build-cmake` to perform an initial _native_ build for the _build_
-system before cross-compilation for th _host_ system, set the
-`copy_from_native_build` option in the `py-build-cmake.cross.toml` file.  
-The build process will then be as follows:
-
-1. Configure the project for the _build_ system, with an additional CMake option
-   `-D PY_BUILD_CMAKE_NATIVE_INSTALL_DIR:PATH="..."` that points to a temporary
-   folder where the _build_ system's version of the project will be installed 
-   in step (3).
-2. Build the project for the _build_ system.
-3. Install the project for the _build_ system into 
-   `PY_BUILD_CMAKE_NATIVE_INSTALL_DIR`.
-4. Configure the project for the _host_ system. The 
-   `PY_BUILD_CMAKE_NATIVE_INSTALL_DIR` CMake option is included again, and 
-   points to the same folder where step (3) installed the project for the _build_
-   system. If you need executables for building, add this to the appropriate 
-   CMake search paths in your CMakeLists.txt file. Cross-compilation is selected
-   by setting the `-D CMAKE_TOOLCHAIN_FILE:FILEPATH="..."` CMake option.
-5. Build the project for the _host_ system.
-6. Install the project for the _host_ system into a staging directory (different
-   from `PY_BUILD_CMAKE_NATIVE_INSTALL_DIR`).
-7. If any patterns were specified using the `copy_from_native_build` option,
-   match these against the files in `PY_BUILD_CMAKE_NATIVE_INSTALL_DIR`, and 
-   move the matching files from `PY_BUILD_CMAKE_NATIVE_INSTALL_DIR` to the 
-   staging directory, to be included in the package.
-
-The last step provides a convenient way to install stubs when cross-compiling:
-generating stubs requires loading the compiled extension modules, so cannot be
-done for _host_ modules on the _build_ system. Instead, the stubs are generated
-from the _build_ modules in step (2), and then copied into the _host_ package in
-step (7).
+The Python implementation, version, ABI and architecture were already discussed
+in a previous section. The CMake toolchain file simply points to a file in the
+same directory as the configuration file. We'll have a look at what it does
+shortly. Finally, the `TOOLCHAIN_PYTHON_VERSION` variable tells the toolchain
+file which version of Python to add to the CMake search paths.
 
-### Caveats
+### Cross-compile the pybind11-project example package using py-build-cmake
+
+We now have our toolchain, the Python installation, and a configuration file
+that selects the correct toolchain and Python version, so we are ready to
+cross-compile our first package. We'll use the `pybind11-project` example that's
+included with `py-build-cmake`.
+
+```sh
+# Install PyPA build as a build front-end
+python3 -m pip install -U build
+# Cross-compile the example package using our cross-compilation configuration
+python3 -m build -w examples/pybind11-project \
+    -C cross="$PWD/toolchains/x-tools/aarch64-rpi3-linux-gnu.python3.11.py-build-cmake.cross.toml"
+```
+If everything worked as expected, you should see output similar to the following.
+```sh
+-- The C compiler identification is GNU 14.2.0
+-- The CXX compiler identification is GNU 14.2.0
+-- Check for working C compiler: py-build-cmake/toolchains/x-tools/aarch64-rpi3-linux-gnu/bin/aarch64-rpi3-linux-gnu-gcc - skipped
+[...]
+-- Found Python3: py-build-cmake/toolchains/x-tools/aarch64-rpi3-linux-gnu/python3.11/usr/local/include/python3.11 (found version "3.11.10") found components: Development.Module
+-- Detecting pybind11 CMake location
+-- pybind11 CMake location: /tmp/build-env-xxxxx/lib/python3.9/site-packages/pybind11/share/cmake/pybind11
+-- Performing Test HAS_FLTO
+-- Performing Test HAS_FLTO - Success
+-- Found pybind11: /tmp/build-env-xxxxx/lib/python3.9/site-packages/pybind11/include (found version "2.13.6")
+-- Configuring done (1.4s)
+-- Generating done (0.0s)
+-- Build files have been written to: py-build-cmake/examples/pybind11-project/.py-build-cmake_cache/cp311-cp311-manylinux_2_27_aarch64
+[ 50%] Building CXX object CMakeFiles/_add_module.dir/src/add_module.cpp.o
+[100%] Linking CXX shared module _add_module.cpython-311-aarch64-linux-gnu.so
+[100%] Built target _add_module
+-- Installing: /tmp/xxxxx/staging/pybind11_project/_add_module.cpython-311-aarch64-linux-gnu.so
+[...]
+Successfully built pybind11_project-0.3.0-cp311-cp311-manylinux_2_27_aarch64.whl
+```
+You can see that CMake is using the cross-compiler we downloaded, and that it
+managed to locate the version of Python we requested (CPython 3.11 for AArch64).
+It is important to verify the module extension suffix
+(`.cpython-311-aarch64-linux-gnu.so` in this case) and the Wheel tags
+(`cp311-cp311-manylinux_2_27_aarch64`).
+
+You can now copy the Wheel package in `examples/pybind11-project/dist/pybind11_project-0.3.0-cp311-cp311-manylinux_2_27_aarch64.whl`
+to e.g. a Raspberry Pi and install it using `pip install`.
+
+### Automated Bash scripts
+
+The included `scripts/download-cross-toolchains-linux.sh` script downloads the
+toolchains and Python installations for common architectures and current
+versions of Python. You can then run the `examples/pybind11-project/cross-compile-linux.sh`
+and `examples/nanobind-project/cross-compile-linux.sh` scripts to cross-compile
+these example packages for this wide range of configurations.
+
+```sh
+./scripts/download-cross-toolchains-linux.sh
+./examples/pybind11-project/cross-compile-linux.sh
+./examples/nanobind-project/cross-compile-linux.sh
+```
+You can find the resulting Wheel packages in the
+`examples/pybind11-project/dist` directory:
+```sh
+examples/pybind11-project/dist
+├── pybind11_project-0.3.0-cp37-cp37m-linux_armv6l.whl
+├── pybind11_project-0.3.0-cp37-cp37m-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-cp37-cp37m-manylinux_2_27_armv7l.whl
+├── pybind11_project-0.3.0-cp37-cp37m-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-cp38-cp38-linux_armv6l.whl
+├── pybind11_project-0.3.0-cp38-cp38-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-cp38-cp38-manylinux_2_27_armv7l.whl
+├── pybind11_project-0.3.0-cp38-cp38-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-cp39-cp39-linux_armv6l.whl
+├── pybind11_project-0.3.0-cp39-cp39-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-cp39-cp39-manylinux_2_27_armv7l.whl
+├── pybind11_project-0.3.0-cp39-cp39-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-cp310-cp310-linux_armv6l.whl
+├── pybind11_project-0.3.0-cp310-cp310-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-cp310-cp310-manylinux_2_27_armv7l.whl
+├── pybind11_project-0.3.0-cp310-cp310-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-cp311-cp311-linux_armv6l.whl
+├── pybind11_project-0.3.0-cp311-cp311-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-cp311-cp311-manylinux_2_27_armv7l.whl
+├── pybind11_project-0.3.0-cp311-cp311-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-cp312-cp312-linux_armv6l.whl
+├── pybind11_project-0.3.0-cp312-cp312-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-cp312-cp312-manylinux_2_27_armv7l.whl
+├── pybind11_project-0.3.0-cp312-cp312-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-cp313-cp313-linux_armv6l.whl
+├── pybind11_project-0.3.0-cp313-cp313-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-cp313-cp313-manylinux_2_27_armv7l.whl
+├── pybind11_project-0.3.0-cp313-cp313-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-pp37-pypy37_pp73-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-pp37-pypy37_pp73-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-pp38-pypy38_pp73-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-pp38-pypy38_pp73-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-pp39-pypy39_pp73-manylinux_2_27_aarch64.whl
+├── pybind11_project-0.3.0-pp39-pypy39_pp73-manylinux_2_27_x86_64.whl
+├── pybind11_project-0.3.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.whl
+└── pybind11_project-0.3.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.whl
+```
+
+### A closer look at the CMake toolchain files
+
+Let us now look at `toolchains/x-tools/aarch64-rpi3-linux-gnu.python.toolchain.cmake`
+more closely:
+```cmake
+include("${CMAKE_CURRENT_LIST_DIR}/aarch64-rpi3-linux-gnu.toolchain.cmake")
+
+# [...]
+
+# User options
+set(TOOLCHAIN_PYTHON_VERSION "3" CACHE STRING "Python version to locate")
+option(TOOLCHAIN_NO_FIND_PYTHON "Do not set the FindPython hints" Off)
+option(TOOLCHAIN_NO_FIND_PYTHON3 "Do not set the FindPython3 hints" Off)
+
+# [...]
+
+# Internal variables
+set(TOOLCHAIN_PYTHON_ROOT "${CMAKE_CURRENT_LIST_DIR}/${CROSS_GNU_TRIPLE}/python${TOOLCHAIN_PYTHON_VERSION}")
+list(APPEND CMAKE_FIND_ROOT_PATH "${TOOLCHAIN_PYTHON_ROOT}")
+
+# Determine the paths and other properties of the Python installation
+function(toolchain_locate_python)
+    # [...]
+endfunction()
+
+if (NOT TOOLCHAIN_NO_FIND_PYTHON OR NOT TOOLCHAIN_NO_FIND_PYTHON3)
+    # [...]
+    # Set FindPython hints and artifacts
+    if (NOT TOOLCHAIN_NO_FIND_PYTHON)
+        set(Python_ROOT_DIR ${TOOLCHAIN_PYTHON_ROOT_DIR} CACHE PATH "" FORCE)
+        set(Python_LIBRARY ${TOOLCHAIN_PYTHON_LIBRARY} CACHE FILEPATH "" FORCE)
+        set(Python_INCLUDE_DIR ${TOOLCHAIN_PYTHON_INCLUDE_DIR} CACHE PATH "" FORCE)
+        set(Python_INTERPRETER_ID "Python" CACHE STRING "" FORCE)
+    endif()
+    # Set FindPytho3 hints and artifacts
+    if (NOT TOOLCHAIN_NO_FIND_PYTHON3)
+        set(Python3_ROOT_DIR ${TOOLCHAIN_PYTHON_ROOT_DIR} CACHE PATH "" FORCE)
+        set(Python3_LIBRARY ${TOOLCHAIN_PYTHON_LIBRARY} CACHE FILEPATH "" FORCE)
+        set(Python3_INCLUDE_DIR ${TOOLCHAIN_PYTHON_INCLUDE_DIR} CACHE PATH "" FORCE)
+        set(Python3_INTERPRETER_ID "Python" CACHE STRING "" FORCE)
+    endif()
+    # Set pybind11 hints
+    # [...]
+    set(PYTHON_MODULE_DEBUG_POSTFIX ${PYTHON_MODULE_DEBUG_POSTFIX} CACHE INTERNAL "")
+    set(PYTHON_MODULE_EXTENSION ${PYTHON_MODULE_EXTENSION} CACHE INTERNAL "")
+    set(PYTHON_IS_DEBUG ${PYTHON_IS_DEBUG} CACHE INTERNAL "")
+    # Set nanobind hints
+    # [...]
+    set(NB_SUFFIX ${NB_SUFFIX} CACHE INTERNAL "")
+    set(NB_SUFFIX_S ${NB_SUFFIX_S} CACHE INTERNAL "")
+endif()
+```
+
+First, it includes the standard toolchain file for the platform (the one that
+sets the platform properties and compiler paths, see below).  
+Next, it declares the options that you might want to configure as a user, such
+as the version of Python to make available, and whether to set CMake's
+[FindPython](https://cmake.org/cmake/help/latest/module/FindPython.html) and
+[FindPython3](https://cmake.org/cmake/help/latest/module/FindPython3.html) hints.  
+Then it adds the selected Python installation to CMake's search path, it
+locates the Python library and include paths, its properties such as the
+ABI and the extension suffix, and sets the FindPython hints.  
+Finally, it sets some specific cache variables that are needed by the
+[pybind11](https://github.com/pybind/pybind11) and [nanobind](https://github.com/wjakob/nanobind)
+frameworks.
+
+The file `toolchains/x-tools/aarch64-rpi3-linux-gnu.toolchain.cmake` contains:
+```cmake
+# System information
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_PROCESSOR "aarch64")
+set(CROSS_GNU_TRIPLE "aarch64-rpi3-linux-gnu"
+    CACHE STRING "The GNU triple of the toolchain to use")
+set(CMAKE_LIBRARY_ARCHITECTURE "aarch64-linux-gnu")
+
+# Compiler flags
+set(CMAKE_C_FLAGS_INIT       "-mcpu=cortex-a53+crc+simd")
+set(CMAKE_CXX_FLAGS_INIT     "-mcpu=cortex-a53+crc+simd")
+set(CMAKE_Fortran_FLAGS_INIT "-mcpu=cortex-a53+crc+simd")
+
+# Search path configuration
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# Packaging
+set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "arm64")
+
+# Compiler binaries
+set(TOOLCHAIN_DIR "${CMAKE_CURRENT_LIST_DIR}/${CROSS_GNU_TRIPLE}")
+set(CMAKE_C_COMPILER "${TOOLCHAIN_DIR}/bin/${CROSS_GNU_TRIPLE}-gcc"
+    CACHE FILEPATH "C compiler")
+set(CMAKE_CXX_COMPILER "${TOOLCHAIN_DIR}/bin/${CROSS_GNU_TRIPLE}-g++"
+    CACHE FILEPATH "C++ compiler")
+set(CMAKE_Fortran_COMPILER "${TOOLCHAIN_DIR}/bin/${CROSS_GNU_TRIPLE}-gfortran"
+    CACHE FILEPATH "Fortran compiler")
+```
+
+### Cross-compilation of dependencies
+
+If your Python package depends on native libraries, you'll have to cross-compile
+these dependencies as well. You can either compile them from source yourself,
+using the CMake toolchain files included with the toolchain, or you can use
+the Conan package manager to build these dependencies for you. A Conan profile
+is included as well, see e.g. `toolchains/x-tools/aarch64-rpi3-linux-gnu.profile.conan`.
+
+---
+
+## Automatic cross-compilation
+
+In order to ensure compatibility with [`cibuildwheel`](https://github.com/pypa/cibuildwheel),
+`py-build-cmake` automatically enables cross-compilation when certain
+environment variables are set.
+
+### Windows
+
+Cross-compilation on Windows is enabled if the following conditions are met:
+
+0. The configuration does not yet contain a `[tool.py-build-cmake.cross]` entry,
+1. and the `DIST_EXTRA_CONFIG` environment variable is set,
+2. and that variable points to a configuration file that specifies
+   `build_ext.plat_name`,
+3. and that value differs from the current platform.
+
+The supported values for `build_ext.plat_name` are:
+ - `win32`
+ - `win-amd64`
+ - `win-arm32`
+ - `win-arm64`
+
+As a result, `py-build-cmake` sets the `CMAKE_SYSTEM_NAME`,
+`CMAKE_SYSTEM_PROCESSOR` and `CMAKE_GENERATOR_PLATFORM` CMake options to the
+appropriate values for the given `plat_name`.  
+If `build_ext.library_dirs` is set in the configuration file as well, those
+directories are searched for the Python library, and if found, the
+CMake `{Python,Python3}_LIBRARY` hints are specified. If the Python library is
+part of a Python installation hierarchy that also contains an `include`
+directory, this is specified using the `{Python,Python3}_INCLUDE_DIR` hints.  
+Other CMake options are inherited from the `[tool.py-build-cmake.windows.cmake]`
+configuration in `pyproject.toml`.
+
+### macOS
+
+Cross-compilation on macOS is enabled if the following conditions are met:
+
+0. The configuration does not yet contain a `[tool.py-build-cmake.cross]` entry,
+1. and the `ARCHFLAGS` environment variable is set,
+2. and its value contains one or more flags of the form `-arch XXX`,
+where `XXX` is either `x86_64` or `arm64`,
+3. and the current platform's architecture is not included in this list.
+
+The supported values for `ARCHFLAGS` are:
+ - `-arch x86_64` (Intel)
+ - `-arch arm64` (Apple silicon)
+ - `-arch x86_64 -arch arm64` (Universal 2 fat binaries, both Intel and Apple
+   silicon)
+
+As a result, `py-build-cmake` sets the `CMAKE_SYSTEM_NAME` and
+`CMAKE_OSX_ARCHITECTURES` CMake options to the appropriate values.  
+If the current interpreter is CPython, the `SETUPTOOLS_EXT_SUFFIX` environment
+variable is set as well.  
+Other CMake options are inherited from the `[tool.py-build-cmake.mac.cmake]`
+configuration in `pyproject.toml`.
+
+If the current platform's architecture is included in the `ARCHFLAGS`
+(violating condition 3), cross-compilation will not be enabled, but the
+`CMAKE_OSX_ARCHITECTURES` CMake option will still be set. (This is the case for
+universal wheels.)
+
+### Linux
 
-Be careful not to copy any incompatible binaries from the _native_ build
-into the _host_ package.
+Since `cibuildwheel` does not support cross-compilation on Linux,
+`py-build-cmake` does not enable automatic cross-compilation for this platform.
+By default, `cibuildwheel` will try to build your package in an emulated ARM64
+container. This can be very slow, so it is recommended to use explicit
+cross-compilation as described [above](#complete-cross-compilation-workflow).
diff --git a/docs/Debug.md b/docs/Debug.md
index 8445ecc..e7e191a 100644
--- a/docs/Debug.md
+++ b/docs/Debug.md
@@ -3,7 +3,7 @@
 # Debugging
 
 You'll most likely end up in a situation where you'd like to debug your C++
-code while it is being called from Python. For this reason, py-build-cmake 
+code while it is being called from Python. For this reason, py-build-cmake
 allows you to install multiple configurations of your project (e.g. `Debug` and
 `Release` builds). This page covers how to get your package ready for debugging.
 
@@ -29,12 +29,14 @@ options = { "CMAKE_DEBUG_POSTFIX:STRING" = "_d" }
 ## CMakeLists.txt and C++ code
 
 Since the name of the Python module now depends on whether it's a debug build or
-not, we have to make sure that the Python bindings use the correct name: 
+not, we have to make sure that the Python bindings use the correct name:
 In your CMakeLists.txt script, add a macro that defines the `MODULE_NAME` as the
 base name of the extension module (which includes the `_d` suffix):
 
 ```cmake
 pybind11_add_module(_add_module MODULE "src/add_module.cpp")
+set_target_properties(_add_module PROPERTIES
+    DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}${PYTHON_MODULE_DEBUG_POSTFIX}")
 target_compile_definitions(_add_module PRIVATE
     MODULE_NAME=$<TARGET_FILE_BASE_NAME:_add_module>)
 ```
@@ -74,7 +76,7 @@ and `build` not to use a temporary build folder using the respective
 
 ## Debugging in VSCode
 
-First, create a task to build the package. This task will be executed before 
+First, create a task to build the package. This task will be executed before
 each debug session. In `.vscode/tasks.json`, add:
 
 ```json
@@ -133,10 +135,10 @@ Next, define the debug configuration in `.vscode/launch.json`:
     ]
 }
 ```
-Note how the program to debug is the Python interpreter itself. The Python 
+Note how the program to debug is the Python interpreter itself. The Python
 script to execute is passed as an argument.  
 The environment variable `PYBIND11_PROJECT_PYTHON_DEBUG` is set, which causes
-the Python wrapper to load the debug version of the extension module, as 
+the Python wrapper to load the debug version of the extension module, as
 explained above.
 
 Now open `src/add_module.cpp` and add a breakpoint in the `add` function:
@@ -144,7 +146,7 @@ Now open `src/add_module.cpp` and add a breakpoint in the `add` function:
 ![Breakpoint in the add function](images/breakpoint.png)
 
 If you now press <kbd>F5</kbd> to launch the debugger, the execution will be
-paused when the Python script calls the `add` function, and you can debug the 
+paused when the Python script calls the `add` function, and you can debug the
 program as usual:
 
 ![Execution paused in the add function](images/debug.png)
@@ -164,7 +166,7 @@ function(install_debug_syms target component dest_lib dest_bin)
         install(FILES "$<TARGET_PDB_FILE:${target}>"
             DESTINATION ${dest_bin}
             CONFIGURATIONS Debug RelWithDebInfo
-            COMPONENT ${component} 
+            COMPONENT ${component}
             OPTIONAL EXCLUDE_FROM_ALL)
     elseif (CMAKE_STRIP AND CMAKE_OBJCOPY)
         set(DEBUG_FILE "$<TARGET_FILE_NAME:${target}>.debug")
diff --git a/docs/Editable-install.md b/docs/Editable-install.md
index 3ffb0ee..5888163 100644
--- a/docs/Editable-install.md
+++ b/docs/Editable-install.md
@@ -23,16 +23,27 @@ Alternatively, you can add it to your local configuration,
 
 ```toml
 [editable]
-mode = "symlink"
+mode = "hook"
 ```
 
-> **Note**: only Python files are made “editable”. You'll still have to run
->           `pip install -e .` again to rebuild your C extension modules if you
->           modify any C/C++/Fortran source files.
+> **Note**: by default, only Python files are made “editable”. You'll still have
+>           to run `pip install -e .` again to rebuild your C extension modules
+>           if you modify any C/C++/Fortran source files.  
+>           To automatically rebuild C extension modules, set
+>           `editable.mode = "symlink"` and `editable.build_hook = true` in the
+>           [configuration](Config.html).
+>           See the [Build hooks](#build-hooks) section below for details.
 
-The following sections go into the details of the different modes.
+```toml
+[tool.py-build-cmake.editable]
+mode = "symlink"
+build_hook = true
+```
 
-## Wrapper (default)
+The following sections go into the details of the different editable
+installation modes.
+
+## Wrapper
 
 The `wrapper` mode installs all files generated using CMake, but not the Python
 source files in your package. To make these Python files available, a wrapper
@@ -147,7 +158,9 @@ class EditablePathFinder(PathFinder):
     def find_spec(self, name, path=None, target=None):
         if name.split('.', 1)[0] != self.name:
             return None
-        path = (path or []) + [self.extra_path]
+        if path is None:
+            path = []
+        path.append(self.extra_path)
         return super().find_spec(name, path, target)
 
 def install(name: str):
@@ -166,7 +179,7 @@ This file is loaded by the `my_package.pth` file, which contains:
 import my_package_editable_hook
 ```
 
-## Symlink
+## Symlink (default)
 
 The disadvantage of the previous two methods is that they split up the package
 across different folders, and not all external tools and IDEs deal with this
@@ -209,11 +222,57 @@ The Wheel package format does not support symbolic links, so only a `.pth` file
 is included in the Wheel, and the actual files and symlinks are copied to a
 hidden folder in the project's source directory, [as proposed by PEP 660](https://peps.python.org/pep-0660/#what-to-put-in-the-wheel).
 
+Note that any binaries installed into `my_package-1.2.3.data/scripts` will not
+be in the path, since they are installed in the `.py-build-cmake_cache/editable`
+folder, not in `site-packages/bin` or `site-packages/Scripts`.
+
+# Build hooks
+
+During development, py-build-cmake can be configured to automatically recompile
+any C extension modules that changed. This is done by setting the
+`editable.build_hook` option to `true`. Under the hood, this will cause a hook
+to be installed in the [meta path](https://docs.python.org/3/reference/import.html#import-hooks),
+which will invoke `cmake --build` and `cmake --install` when your package is
+first imported.
+
+Modern build systems like Ninja are very fast at figuring out whether anything
+has to be recompiled, so the overhead of this hook is relatively low when no
+files changed.
+
+Keep in mind that C extension modules cannot be unloaded or reloaded after they
+have been imported once. You need to restart the Python interpreter for any
+changes to take effect. This is why the build is only carried out during the
+first import (and before the module is first loaded).
+
+To avoid depending on packages in Pip's temporary build directory or virtual
+environment, you can use the `--no-build-isolation` flag:
+
+```sh
+pip install -e . --no-build-isolation
+```
+
+This requires you to install any dependencies into your environment beforehand.
+
+The only mode that is currently supported is `symlink`. This is because
+`symlink` mode installs the extension modules into a hidden folder inside of the
+project folder, whereas the `hook` and `wrapper` modes include the extension
+modules in the package. In such a case, the build hook would have to install its
+artifacts into the Python site-packages directory directly. This comes with the
+risk of installing files that were not included in the original package's RECORD
+(e.g. if the user modifies any CMake code or options), and these files would not
+be cleaned up when uninstalling the package. Files left behind by old packages
+could cause all kinds of issues that are hard to debug, so py-build-cmake simply
+does not allow this.
+
 ---
 
 <small>
 
 (\*) Specifically, to create symbolic links on Windows without administrator
 rights, you need to enable [Developer Mode](https://learn.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development).
+Otherwise, you'll see `OSError: symbolic link privilege not held` or
+`[WinError 1314] A required privilege is not held by the client`. If you
+cannot change the privilege, you can override the editable mode in a
+`py-build-cmake.local.toml` file as described above.
 
 </small>
diff --git a/docs/FAQ.md b/docs/FAQ.md
index 6b4dc6c..2ae210f 100644
--- a/docs/FAQ.md
+++ b/docs/FAQ.md
@@ -18,7 +18,7 @@ declarative configuration files like `setup.cfg` and `pyproject.toml` instead.
 From the [Setuptools quickstart guide](https://setuptools.pypa.io/en/latest/userguide/quickstart.html):
 
 > The landscape of Python packaging is shifting and `Setuptools` has evolved to
-> only provide backend support, no longer being the de-facto packaging tool in 
+> only provide backend support, no longer being the de-facto packaging tool in
 > the market. Every python package must provide a `pyproject.toml` and specify
 > the backend (build system) it wants to use. The distribution can then be
 > generated with whatever tool that provides a `build sdist`-like functionality.
@@ -42,16 +42,16 @@ For more information about `setup.py` and Python packaging in general, see:
 ## The build fails. How can I find out what's going on?
 
 You can enable py-build-cmake's verbose mode to make it print information about
-the configuration, the exact subprocesses it invokes, the configure and build 
+the configuration, the exact subprocesses it invokes, the configure and build
 environments, and so on.
 
-When using a tool like PyPA `build`, you can use the `-C` flag to pass the 
+When using a tool like PyPA `build`, you can use the `-C` flag to pass the
 `verbose` option:
 ```sh
 python -m build . -C verbose
 ```
 
-For tools that do not allow options to be passed to the backend directly, you
+If you cannot easily change the command line options directly, you
 can set the environment variable `PY_BUILD_CMAKE_VERBOSE`:
 ```sh
 PY_BUILD_CMAKE_VERBOSE=1 pip install . -v # Linux/macOS
@@ -63,18 +63,36 @@ Remove-Item Env:PY_BUILD_CMAKE_VERBOSE
 ```
 Also note the `-v` flag to get pip to print the build output.
 
+For [cibuildwheel](https://github.com/pypa/cibuildwheel), you can add the
+following options to `pyproject.toml` to see all output from the build:
+```toml
+[tool.cibuildwheel]
+build-verbosity = 1
+environment = { PY_BUILD_CMAKE_VERBOSE="1" }
+```
+
 When inspecting the output, be aware that output of subprocesses is often much
 higher up than the final error message or backtrace. For example, if you get an
 error saying that the invocation of CMake failed, you'll have to scroll up to
-see the actual CMake output.
+see the actual CMake and compiler output.
 
 ## How can I perform a clean rebuild?
 
-To fully reconfigure and rebuild a project, simply remove py-build-cmake's cache
-directory:
+To fully reconfigure and rebuild a project (e.g. after changing the CMake
+generator, or after modifying environment variables like `CFLAGS` that affect
+the initialization of CMake cache variables), simply remove py-build-cmake's
+cache directory:
 ```sh
 rm -r .py-build-cmake_cache
 ```
+Often times, it is enough to simply delete the `CMakeCache.txt` file, without
+performing a full rebuild:
+```sh
+# For a specific version and architecture (use tab completion):
+rm .py-build-cmake_cache/cp311-cp311-linux_x86_64/CMakeCache.txt
+# All versions and architectures:
+rm .py-build-cmake_cache/*/CMakeCache.txt
+```
 
 ## How to upload my package to PyPI?
 
@@ -92,7 +110,7 @@ each combination of Python version and platform you wish to support
 You can use a tool like [cibuildwheel](https://github.com/pypa/cibuildwheel) to
 automate the build process for this large matrix of platform/version
 combinations. Continuous integration providers like GitHub Actions also provide
-job matrix capabilities. For example, the [alpaqa](https://github.com/kul-optec/alpaqa/blob/c8c1d5d37a770428ae4785356110af874567d3ce/.github/workflows/wheel.yml#L75-L166)
+job matrix capabilities. For example, the [alpaqa](https://github.com/kul-optec/alpaqa/blob/bac0067c312a781c444204d0918339f4cb35ab1c/.github/workflows/wheel.yml#L75-L173)
 library uses the following matrix to build the package for multiple
 architectures and Python versions:
 
@@ -100,20 +118,27 @@ architectures and Python versions:
 strategy:
   matrix:
     pypy: ['', pypy]
-    python-version: ['3.8', '3.9', '3.10', '3.11']
+    python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
     host: [x86_64-centos7-linux-gnu, armv7-neon-linux-gnueabihf, armv6-rpi-linux-gnueabihf, aarch64-rpi3-linux-gnu]
+    include:
+      - python-version: '3.8'
+        pypy-version: '7.3.11'
+      - python-version: '3.9'
+        pypy-version: '7.3.12'
+      - python-version: '3.10'
+        pypy-version: '7.3.12'
     exclude:
-      - pypy: pypy
-        python-version: '3.10'
       - pypy: pypy
         python-version: '3.11'
+      - pypy: pypy
+        python-version: '3.12'
       - pypy: pypy
         host: armv7-neon-linux-gnueabihf
       - pypy: pypy
         host: armv6-rpi-linux-gnueabihf
 ```
 
-The same workflow file also contains some steps test the resulting wheels and
+The same workflow file also contains some steps to test the resulting wheels and
 upload them to to PyPI. It's a good idea to check that the package version
 matches the Git tag before uploading anything. Also note the use of a [secret](https://docs.github.com/en/actions/security-guides/encrypted-secrets)
 for the PyPI access token.
@@ -128,6 +153,7 @@ export ARCHFLAGS='-arch arm64 -arch x86_64'
 ```
 
 To build packages for multiple architectures on Linux, I recommend [cross-compilation](./Cross-compilation.html).
-This ensures that your packge doesn't depend on any libraries (including GLIBC) from the build server.
-You can use the cross-compilers from <https://github.com/tttapa/docker-cross-python>, which also include
-pre-built cross-compiled versions of Python.
+This ensures that your package doesn't depend on any libraries (including GLIBC)
+from the build server. You can use the modern GCC 13.1 cross-compilers from
+<https://github.com/tttapa/docker-cross-python>, which also include pre-built
+cross-compiled versions of Python.
diff --git a/docs/Package-structure.md b/docs/Package-structure.md
index 7fbf329..b1019d4 100644
--- a/docs/Package-structure.md
+++ b/docs/Package-structure.md
@@ -2,5 +2,5 @@
 
 # Package structure
 
-For a detailed discussion of the directory structure of a Python package, 
+For a detailed discussion of the directory structure of a Python package,
 please see the README of [examples/minimal](https://github.com/tttapa/py-build-cmake/tree/main/examples/minimal).
diff --git a/docs/_config.yml b/docs/_config.yml
index edcb320..a1667d7 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -1,2 +1,2 @@
 markdown: GFM
-title: ''
\ No newline at end of file
+title: ''
diff --git a/examples/README.md b/examples/README.md
index 2ebdaec..632951c 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -16,11 +16,11 @@
     type checking and autocompletion, unit tests using [pytest](https://github.com/pytest-dev/pytest),
     a configuration for [debugging the C++ code](https://tttapa.github.io/py-build-cmake/Debug.html),
     and example configurations for [cross-compilation](https://tttapa.github.io/py-build-cmake/Cross-compilation.html).
-- `nanobind-project`: Very similar to `pybind11_project`, but using the more
-    modern [nanobind](https://github.com/wjakob/nanobind) library to generate
-    the Python bindings instead of pybind11.
+- [`nanobind-project`](./nanobind-project): Very similar to `pybind11_project`,
+    but using the more modern [nanobind](https://github.com/wjakob/nanobind)
+    library to generate the Python bindings instead of pybind11.
 - [`minimal-debug-component`](./minimal-debug-component):
-    Largely the same as the [minimal](../minimal) example, but uses 
+    Largely the same as the [minimal](../minimal) example, but uses
     py-build-cmake's `build_component` backend to package the debugging symbols
     in a separate, optional package.
 
diff --git a/examples/minimal-debug-component/.gitignore b/examples/minimal-debug-component/.gitignore
index 02383f8..8efbdd1 100644
--- a/examples/minimal-debug-component/.gitignore
+++ b/examples/minimal-debug-component/.gitignore
@@ -3,4 +3,4 @@ __pycache__
 *.pyc
 build
 dist
-wheelhouse
\ No newline at end of file
+wheelhouse
diff --git a/examples/minimal-debug-component/.vscode/settings.json b/examples/minimal-debug-component/.vscode/settings.json
index ec5be40..ff489e2 100644
--- a/examples/minimal-debug-component/.vscode/settings.json
+++ b/examples/minimal-debug-component/.vscode/settings.json
@@ -1,3 +1,3 @@
 {
     "python.linting.mypyEnabled": true
-}
\ No newline at end of file
+}
diff --git a/examples/minimal-debug-component/CMakeLists.txt b/examples/minimal-debug-component/CMakeLists.txt
index 9b3d1fc..5650297 100644
--- a/examples/minimal-debug-component/CMakeLists.txt
+++ b/examples/minimal-debug-component/CMakeLists.txt
@@ -4,4 +4,4 @@ project(minimal-dev)
 # You can add development-specific options here, such as warnings, tests,
 # coverage, etc.
 
-add_subdirectory(src)
\ No newline at end of file
+add_subdirectory(src)
diff --git a/examples/minimal-debug-component/README.md b/examples/minimal-debug-component/README.md
index ecfb1bf..b9d3f89 100644
--- a/examples/minimal-debug-component/README.md
+++ b/examples/minimal-debug-component/README.md
@@ -1,6 +1,6 @@
 # Minimal debug component
 
-Largely the same as the [minimal](../minimal) example, but uses 
+Largely the same as the [minimal](../minimal) example, but uses
 py-build-cmake's `build_component` backend to package the debugging symbols
 in a separate, optional package.
 
diff --git a/examples/minimal-debug-component/debug/pyproject.toml b/examples/minimal-debug-component/debug/pyproject.toml
index 5dc0723..eb8f7ab 100644
--- a/examples/minimal-debug-component/debug/pyproject.toml
+++ b/examples/minimal-debug-component/debug/pyproject.toml
@@ -1,21 +1,22 @@
 [project]
-name = "minimal-debug"
+name = "minimal-comp-debug"
 readme = "README.md"
 requires-python = ">=3.7"
 license = { "file" = "../LICENSE" }
 authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
-keywords = ["addition", "subtraction", "pybind11"]
+keywords = ["example", "addition", "subtraction", "debug"]
 classifiers = []
 urls = { "Documentation" = "https://tttapa.github.io/" }
-dependencies = ["minimal_comp==0.1.8"]
-version = "0.1.8"
+dependencies = ["minimal-comp==0.3.0"]
+version = "0.3.0"
 description = "Debug symbols for the minimal package."
 
 [build-system]
-requires = ["py-build-cmake~=0.1.8", "pybind11", "pybind11-stubgen"]
+requires = ["py-build-cmake~=0.3.0"]
 build-backend = "py_build_cmake.build_component"
 
-[tool.py-build-cmake.component]
+[tool.py-build-cmake]
 main_project = ".."
+[tool.py-build-cmake.component]
 install_components = ["python_modules_debug"]
 install_only = true
diff --git a/examples/minimal-debug-component/pyproject.toml b/examples/minimal-debug-component/pyproject.toml
index cdf69bb..bf7ee7b 100644
--- a/examples/minimal-debug-component/pyproject.toml
+++ b/examples/minimal-debug-component/pyproject.toml
@@ -4,7 +4,7 @@ readme = "README.md"
 requires-python = ">=3.7"
 license = { "file" = "LICENSE" }
 authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
-keywords = ["addition", "subtraction", "pybind11"]
+keywords = ["example", "addition", "subtraction"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "License :: OSI Approved :: MIT License",
@@ -14,6 +14,8 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: MacOS",
@@ -24,10 +26,10 @@ dynamic = ["version", "description"]
 
 [project.optional-dependencies]
 docs = ["sphinx~=5.1", "matplotlib", "breathe", "furo"]
-debug = ["minimal-debug==0.1.8"]
+debug = ["minimal-debug==0.3.0"]
 
 [build-system]
-requires = ["py-build-cmake~=0.1.8"]
+requires = ["py-build-cmake~=0.3.0"]
 build-backend = "py_build_cmake.build"
 
 [tool.py-build-cmake.module]
@@ -46,5 +48,4 @@ install_components = ["python_modules"]
 [tool.py-build-cmake.stubgen]
 
 [tool.pytest.ini_options]
-minversion = "6.0"
-testpaths = ["test"]
+testpaths = ["tests"]
diff --git a/examples/minimal-debug-component/src-python/minimal_comp/__init__.py b/examples/minimal-debug-component/src-python/minimal_comp/__init__.py
index e9c99ba..f445557 100644
--- a/examples/minimal-debug-component/src-python/minimal_comp/__init__.py
+++ b/examples/minimal-debug-component/src-python/minimal_comp/__init__.py
@@ -1,4 +1,5 @@
 """
 A simple, minimal example of building a Python C module using CMake.
 """
-__version__ = '0.1.8'
\ No newline at end of file
+
+__version__ = "0.3.0"
diff --git a/examples/minimal-debug-component/src-python/minimal_comp/add_module.py b/examples/minimal-debug-component/src-python/minimal_comp/add_module.py
index 57e10fb..6487377 100644
--- a/examples/minimal-debug-component/src-python/minimal_comp/add_module.py
+++ b/examples/minimal-debug-component/src-python/minimal_comp/add_module.py
@@ -1 +1 @@
-from ._add_module import *
\ No newline at end of file
+from ._add_module import *  # noqa: F403
diff --git a/examples/minimal-debug-component/src/CMakeLists.txt b/examples/minimal-debug-component/src/CMakeLists.txt
index 07f737c..6094fe0 100644
--- a/examples/minimal-debug-component/src/CMakeLists.txt
+++ b/examples/minimal-debug-component/src/CMakeLists.txt
@@ -2,10 +2,10 @@ cmake_minimum_required(VERSION 3.17)
 project(minimal)
 
 # Find the Python development files
-find_package(Python3 REQUIRED COMPONENTS Development.Module)
+find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
 
 # Add the module to compile
-Python3_add_library(_add_module MODULE "add_module.c")
+Python3_add_library(_add_module MODULE "add_module.c" WITH_SOABI)
 
 # Install the module
 install(TARGETS _add_module
diff --git a/examples/minimal-debug-component/src/_add_module.pyi b/examples/minimal-debug-component/src/_add_module.pyi
index 7b2b623..a0c348f 100644
--- a/examples/minimal-debug-component/src/_add_module.pyi
+++ b/examples/minimal-debug-component/src/_add_module.pyi
@@ -1,3 +1,3 @@
 # Python stub file for the _add_module extension module
 
-def add(a: int, b: int) -> int: ...
\ No newline at end of file
+def add(a: int, b: int) -> int: ...
diff --git a/examples/minimal-debug-component/test/test_component.py b/examples/minimal-debug-component/test/test_component.py
deleted file mode 100644
index 9492047..0000000
--- a/examples/minimal-debug-component/test/test_component.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import sys
-
-def test_component():
-    try:
-        # Not available in Python 3.7, 3.8
-        from importlib.resources import files
-    except ImportError:
-        return
-
-    contents = [
-        resource.name for resource in files('minimal_comp').iterdir()
-        if resource.is_file()
-    ]
-    print(contents)
-    assert sys.platform != "linux" or '_add_module.so.debug' in contents
-    assert sys.platform != "win32" or '_add_module.pdb' in contents
diff --git a/examples/minimal-debug-component/test/test_add_module.py b/examples/minimal-debug-component/tests/test_add_module.py
similarity index 98%
rename from examples/minimal-debug-component/test/test_add_module.py
rename to examples/minimal-debug-component/tests/test_add_module.py
index 11d9164..84948e5 100644
--- a/examples/minimal-debug-component/test/test_add_module.py
+++ b/examples/minimal-debug-component/tests/test_add_module.py
@@ -1,12 +1,15 @@
-from minimal_comp.add_module import add
 import pytest
+from minimal_comp.add_module import add
+
 
 def test_add_positive():
     assert add(1, 2) == 3
 
+
 def test_add_negative():
     assert add(1, -2) == -1
 
+
 def test_add_string():
     with pytest.raises(TypeError):
         add("foo", "bar")
diff --git a/examples/minimal-debug-component/tests/test_component.py b/examples/minimal-debug-component/tests/test_component.py
new file mode 100644
index 0000000..18e9f84
--- /dev/null
+++ b/examples/minimal-debug-component/tests/test_component.py
@@ -0,0 +1,29 @@
+import re
+import sys
+
+import pytest
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9),
+    reason="No importlib.resources support on older versions of Python",
+)
+@pytest.mark.skipif(
+    sys.platform not in ["linux", "win32"],
+    reason="No separate debug symbol files on macOS",
+)
+def test_component():
+    from importlib.resources import files
+
+    contents = [
+        resource.name
+        for resource in files("minimal_comp").iterdir()
+        if resource.is_file()
+    ]
+    print(contents)
+    if sys.platform == "linux":
+        patt = re.compile(r"^_add_module(\.\S+)?\.so\.debug$")
+        assert any(map(patt.match, contents))
+    if sys.platform == "win32":
+        patt = re.compile(r"^_add_module(\.\S+)?\.pdb$")
+        assert any(map(patt.match, contents))
diff --git a/examples/minimal-program/.gitignore b/examples/minimal-program/.gitignore
index 02383f8..8efbdd1 100644
--- a/examples/minimal-program/.gitignore
+++ b/examples/minimal-program/.gitignore
@@ -3,4 +3,4 @@ __pycache__
 *.pyc
 build
 dist
-wheelhouse
\ No newline at end of file
+wheelhouse
diff --git a/examples/minimal-program/.vscode/settings.json b/examples/minimal-program/.vscode/settings.json
index ec5be40..ff489e2 100644
--- a/examples/minimal-program/.vscode/settings.json
+++ b/examples/minimal-program/.vscode/settings.json
@@ -1,3 +1,3 @@
 {
     "python.linting.mypyEnabled": true
-}
\ No newline at end of file
+}
diff --git a/examples/minimal-program/CMakeLists.txt b/examples/minimal-program/CMakeLists.txt
index b1fadc3..4117eeb 100644
--- a/examples/minimal-program/CMakeLists.txt
+++ b/examples/minimal-program/CMakeLists.txt
@@ -4,4 +4,4 @@ project(minimal-program-dev)
 # You can add development-specific options here, such as warnings, tests,
 # coverage, etc.
 
-add_subdirectory(src)
\ No newline at end of file
+add_subdirectory(src)
diff --git a/examples/minimal-program/README.md b/examples/minimal-program/README.md
index 0159a8c..6d22d8d 100644
--- a/examples/minimal-program/README.md
+++ b/examples/minimal-program/README.md
@@ -1,12 +1,15 @@
 # Minimal program
 
-Minimal example using CMake and py-build-cmake to build a C++ program and 
+Minimal example using CMake and py-build-cmake to build a C++ program and
 package it as a Python package.
 
 The key takeaway of this example is the installation path of the program: it
 should be in `${PY_BUILD_CMAKE_PACKAGE_NAME}-${PY_BUILD_CMAKE_PACKAGE_VERSION}.data/scripts`,
 as per [PEP 427](https://peps.python.org/pep-0427/). Pip will then automatically
-install it to a folder that's in the `PATH`.
+install it to a folder that's in the `PATH`.  
+Since there are no Python extension modules with specific ABI requirements for
+the Python interpreter, `tool.py-build-cmake.wheel.python_abi` is set
+to `'none'`.
 
 For more information about the file structure and the configuration files,
 please see the [`minimal` example](../minimal).
diff --git a/examples/minimal-program/pyproject.toml b/examples/minimal-program/pyproject.toml
index a0b594e..b8c1249 100644
--- a/examples/minimal-program/pyproject.toml
+++ b/examples/minimal-program/pyproject.toml
@@ -14,6 +14,8 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: MacOS",
@@ -23,7 +25,7 @@ dependencies = []
 dynamic = ["version", "description"]
 
 [build-system]
-requires = ["py-build-cmake~=0.1.8"]
+requires = ["py-build-cmake~=0.3.0"]
 build-backend = "py_build_cmake.build"
 
 [tool.py-build-cmake.module]
@@ -39,7 +41,10 @@ build_type = "RelWithDebInfo"
 source_path = "src"
 build_args = ["-j"]
 install_components = ["python_binaries"]
+find_python = false
+find_python3 = false
+[tool.py-build-cmake.wheel]
+python_abi = "none"
 
 [tool.pytest.ini_options]
-minversion = "6.0"
-testpaths = ["test"]
+testpaths = ["tests"]
diff --git a/examples/minimal-program/src-python/minimal_program_module/__init__.py b/examples/minimal-program/src-python/minimal_program_module/__init__.py
index 03027ba..9f66b1d 100644
--- a/examples/minimal-program/src-python/minimal_program_module/__init__.py
+++ b/examples/minimal-program/src-python/minimal_program_module/__init__.py
@@ -1,4 +1,5 @@
 """
 A simple, minimal example of building a C++ program using CMake.
 """
-__version__ = '0.1.8'
\ No newline at end of file
+
+__version__ = "0.3.0"
diff --git a/examples/minimal-program/src/minimal_program.cpp b/examples/minimal-program/src/minimal_program.cpp
index 52a2732..232cc7d 100644
--- a/examples/minimal-program/src/minimal_program.cpp
+++ b/examples/minimal-program/src/minimal_program.cpp
@@ -2,4 +2,4 @@
 
 int main() {
     std::cout << "Hello, world!\n";
-}
\ No newline at end of file
+}
diff --git a/examples/minimal-program/test/test_minimal_program.py b/examples/minimal-program/tests/test_minimal_program.py
similarity index 92%
rename from examples/minimal-program/test/test_minimal_program.py
rename to examples/minimal-program/tests/test_minimal_program.py
index 69d9be0..d53de1e 100644
--- a/examples/minimal-program/test/test_minimal_program.py
+++ b/examples/minimal-program/tests/test_minimal_program.py
@@ -1,6 +1,7 @@
-import subprocess
 import os
+import subprocess
+
 
 def test_run_program():
-    res = subprocess.run(["minimal_program"], capture_output=True)
+    res = subprocess.run(["minimal_program"], capture_output=True, check=True)
     assert res.stdout.decode("utf-8") == "Hello, world!" + os.linesep
diff --git a/examples/minimal/.gitignore b/examples/minimal/.gitignore
index 02383f8..8efbdd1 100644
--- a/examples/minimal/.gitignore
+++ b/examples/minimal/.gitignore
@@ -3,4 +3,4 @@ __pycache__
 *.pyc
 build
 dist
-wheelhouse
\ No newline at end of file
+wheelhouse
diff --git a/examples/minimal/.vscode/settings.json b/examples/minimal/.vscode/settings.json
index ec5be40..ff489e2 100644
--- a/examples/minimal/.vscode/settings.json
+++ b/examples/minimal/.vscode/settings.json
@@ -1,3 +1,3 @@
 {
     "python.linting.mypyEnabled": true
-}
\ No newline at end of file
+}
diff --git a/examples/minimal/CMakeLists.txt b/examples/minimal/CMakeLists.txt
index 9b3d1fc..5650297 100644
--- a/examples/minimal/CMakeLists.txt
+++ b/examples/minimal/CMakeLists.txt
@@ -4,4 +4,4 @@ project(minimal-dev)
 # You can add development-specific options here, such as warnings, tests,
 # coverage, etc.
 
-add_subdirectory(src)
\ No newline at end of file
+add_subdirectory(src)
diff --git a/examples/minimal/README.md b/examples/minimal/README.md
index 9aaa929..e7f091a 100644
--- a/examples/minimal/README.md
+++ b/examples/minimal/README.md
@@ -47,7 +47,7 @@ minimal
    │       ├── __init__.py
    │       ├── add_module.py
    │       └── py.typed
-   ├── test
+   ├── tests
    │   └── test_add_module.py
    ├── CMakeLists.txt
    ├── LICENSE
@@ -56,7 +56,7 @@ minimal
 ```
 
 `README.md`  
-This file. Will be included in the Python package as the long description and 
+This file. Will be included in the Python package as the long description and
 will be shown on your PyPI project page.
 
 `pyproject.toml`  
@@ -77,7 +77,7 @@ developing your package).
 The folder containing all C, C++ and Fortran code, built using CMake.
 
 `src/CMakeLists.txt`  
-The main CMake script for the C, C++ and Fortran code. It defines how the 
+The main CMake script for the C, C++ and Fortran code. It defines how the
 Python extension module will be built and installed. This is the entry point
 used by py-build-cmake (as defined in pyproject.toml).
 
@@ -110,7 +110,7 @@ contents.
 Tells [mypy](https://github.com/python/mypy) to provide type checking for your
 package, and to look at the stub files.
 
-`test/test_add_module.py`  
+`tests/test_add_module.py`  
 Unit tests for testing the extension module using
 [pytest](https://github.com/pytest-dev/pytest).
 
@@ -118,21 +118,21 @@ Unit tests for testing the extension module using
 
 ## Configuration
 
-We'll now go over the contents of the contents of pyproject.toml in a bit more
+We'll now go over the contents of the pyproject.toml file in a bit more
 detail. Keep in mind that you can always consult the [py-build-cmake documentation](https://tttapa.github.io/py-build-cmake/Config.html)
 for more information about specific options. More information about the
 `pyproject.toml` format can be found at https://packaging.python.org/en/latest/specifications/declaring-project-metadata/.
 
 ```toml
 [build-system]
-requires = ["py-build-cmake~=0.1.8"]
+requires = ["py-build-cmake~=0.3.0"]
 build-backend = "py_build_cmake.build"
 ```
 
 The `build-system` section defines how tools like `pip` and `build` (called
 _build front-ends_) should build your package. We state that the package should
 be built using the `build` module of the `py_build_cmake` package as a backend,
-and that this package should be installed before building by using the 
+and that this package should be installed before building by using the
 `requires` option.
 If you have other build-time requirements, you can add them to the list.
 
@@ -143,7 +143,7 @@ readme = "README.md"
 requires-python = ">=3.7"
 license = { "file" = "LICENSE" }
 authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
-keywords = ["addition", "subtraction", "pybind11"]
+keywords = ["example", "addition", "subtraction"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "License :: OSI Approved :: MIT License",
@@ -153,6 +153,8 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: MacOS",
@@ -162,8 +164,8 @@ dependencies = []
 dynamic = ["version", "description"]
 ```
 
-The `project` section contains all metadata of the package. Its format is 
-defined in [PEP 621](https://www.python.org/dev/peps/pep-0621/), see 
+The `project` section contains all metadata of the package. Its format is
+defined in [PEP 621](https://www.python.org/dev/peps/pep-0621/), see
 https://packaging.python.org/en/latest/specifications/declaring-project-metadata/
 for the full documentation. This metadata will be displayed on PyPI when you
 publish your package.
@@ -189,7 +191,7 @@ directory = "src-python"
 ```
 This is the first py-build-cmake specific section: `module` defines the path
 where it should look for your Python package. You can also include the `name`
-option when your module or package name is different than the name of your 
+option when your module or package name is different from the name of your
 project on PyPI.
 
 ```toml
@@ -201,7 +203,9 @@ distribution. You should include everything needed to build your package, so
 including the C and CMake files. The README.md and LICENSE files mentioned in
 the metadata are included automatically, and so is the entire Python package
 directory.  
-You can use the `exclude` option to exclude specific files.
+You can use the `exclude` option to exclude specific files. Referenced
+directories are always included/excluded recursively. The `'**'` glob pattern is
+not supported.
 
 ```toml
 [tool.py-build-cmake.cmake]
@@ -213,31 +217,31 @@ install_components = ["python_modules"]
 ```
 The `cmake` section defines the settings for invoking CMake when building your
 project. The most important option is the `source_path`, the folder containing
-your main CMakeLists.txt file. The `-j` flag enables parallel builds, and the 
-`install_components` option defines which CMake components to install. In this
-example, the `python_modules` component is defined in [src/CMakeLists.txt](src/CMakeLists.txt).  
+your main CMakeLists.txt file. The `-j` flag enables parallel builds, and the
+`install_components` option defines which CMake components to install into the
+Wheel package. In this example, the `python_modules` component is defined in
+[src/CMakeLists.txt](src/CMakeLists.txt).  
 The `minimum_version` option defines which version of CMake is required to build
-this project. If this version or newer is not found in the PATH, it is added as
-a build requirement and installed by the build frontend (e.g. pip) before 
-building.  
-There are many other options, see the [py-build-cmake documentation](https://tttapa.github.io/py-build-cmake/Config.html#cmake)
-for more details.
+this project. If this version (or newer) is not found in the system PATH, it is
+automatically added as a build requirement and installed by the build frontend
+(e.g. pip) before building.  
+There are many other options, take a moment to look at the [py-build-cmake documentation](https://tttapa.github.io/py-build-cmake/Config.html#cmake)
+for an overview and more detailed explanations.
 
 ```toml
 [tool.py-build-cmake.stubgen]
 ```
 This section enables stub file generation for Python source files using mypy's
-[`stubgen`](https://mypy.readthedocs.io/en/stable/stubgen.html). Refer to the
-py-build-cmake documentation for information about the optional options in this
-section.
+[`stubgen`](https://mypy.readthedocs.io/en/stable/stubgen.html) tool. Refer to
+the [py-build-cmake documentation](https://tttapa.github.io/py-build-cmake/Config.html#cmake)
+for information about the optional options in this section.
 
 ```toml
 [tool.pytest.ini_options]
-minversion = "6.0"
-testpaths = ["test"]
+testpaths = ["tests"]
 ```
 You can also add configuration options for other Python tools, for example, for
-`pytest`. See https://docs.pytest.org/en/7.2.x/reference/customize.html#pyproject-toml for
+`pytest`. See https://docs.pytest.org/en/7.4.x/reference/customize.html#pyproject-toml for
 details.
 
 ---
@@ -253,19 +257,19 @@ distributions. The easiest way to do this is using
 ```sh
 pip install build
 ```
-Then go to the root folder of your project (the one containing the 
+Then go to the root folder of your project (the one containing the
 pyproject.toml file), and start the build:
 
 ```sh
 python -m build .
 ```
-This will first package the source distribution, and then use that to build a
+This will first package the source distribution, and then use it to build a
 binary wheel package for your platform. While building the wheel, py-build-cmake
-will invoke CMake to build your extension modules, and include them in the 
+will invoke CMake to build your extension modules, and include them in the
 wheel.  
-The resulting packages can be found in the dist folder.
+The resulting packages can be found in the `dist` folder.
 
-You could upload these packages to PyPI, as explained in 
+You could upload these packages to PyPI, as explained in
 https://packaging.python.org/en/latest/tutorials/packaging-projects/#uploading-the-distribution-archives.
 
 On Linux, you might want to use [auditwheel](https://github.com/pypa/auditwheel)
@@ -280,10 +284,10 @@ pip install .
 ```
 You can use the `-v` flag to display the full output of the build process
 (e.g. compiler warnings).  
-By default, pip builds packages in a temporary virtual environment, where it 
+By default, pip builds packages in a temporary virtual environment, where it
 first installs all build dependencies. This can be slow, and might not be
 desirable during development. You can use the `--no-build-isolation` flag to
-disable this behavior. 
+disable this behavior.
 See https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-build-isolation
 for more information.
 
@@ -297,7 +301,7 @@ pip install -e .
 ```
 You can again combine it with the `-v` and/or `--no-build-isolation` flags.
 
-Editable mode only affects the Python source files in your package, if you 
+Editable mode only affects the Python source files in your package, if you
 modify the C code for the extension modules or other files generated by CMake,
 you'll have to run `pip install` to build and install them again.
 
@@ -316,8 +320,20 @@ To see the full test output, you can use the `-rP` option.
 ### Cleaning the build folder
 
 By default, a build folder with the name `.py-build-cmake_cache` in the project
-root directory is created. If you make certain changes to your CMake 
-configuration (e.g. switching to a different generator), you might have to 
+root directory is created. If you make certain changes to your CMake
+configuration (e.g. switching to a different generator), you might have to
 delete this folder.  
 There's no harm in just deleting it, and you should add it to your .gitignore
 to prevent checking it in to version control.
+
+---
+
+## Where to go next
+
+You may find the following resources useful:
+
+ - [Frequently asked questions](https://tttapa.github.io/py-build-cmake/FAQ.html)
+ - [Documentation index](https://tttapa.github.io/py-build-cmake)
+ - [More py-build-cmake example projects](https://github.com/tttapa/py-build-cmake/tree/main/examples)
+ - [Official PyPA Python Packaging User Guide](https://packaging.python.org/en/latest/)
+ - [cibuildwheel documentation](https://cibuildwheel.readthedocs.io/en/stable/)
diff --git a/examples/minimal/pyproject.toml b/examples/minimal/pyproject.toml
index d87e141..707b2a4 100644
--- a/examples/minimal/pyproject.toml
+++ b/examples/minimal/pyproject.toml
@@ -4,7 +4,7 @@ readme = "README.md"
 requires-python = ">=3.7"
 license = { "file" = "LICENSE" }
 authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
-keywords = ["addition", "subtraction", "pybind11"]
+keywords = ["example", "addition", "subtraction"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "License :: OSI Approved :: MIT License",
@@ -14,6 +14,8 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: MacOS",
@@ -23,7 +25,7 @@ dependencies = []
 dynamic = ["version", "description"]
 
 [build-system]
-requires = ["py-build-cmake~=0.1.8"]
+requires = ["py-build-cmake~=0.3.0"]
 build-backend = "py_build_cmake.build"
 
 [tool.py-build-cmake.module]
@@ -42,5 +44,4 @@ install_components = ["python_modules"]
 [tool.py-build-cmake.stubgen]
 
 [tool.pytest.ini_options]
-minversion = "6.0"
-testpaths = ["test"]
+testpaths = ["tests"]
diff --git a/examples/minimal/src-python/minimal/__init__.py b/examples/minimal/src-python/minimal/__init__.py
index e9c99ba..f445557 100644
--- a/examples/minimal/src-python/minimal/__init__.py
+++ b/examples/minimal/src-python/minimal/__init__.py
@@ -1,4 +1,5 @@
 """
 A simple, minimal example of building a Python C module using CMake.
 """
-__version__ = '0.1.8'
\ No newline at end of file
+
+__version__ = "0.3.0"
diff --git a/examples/minimal/src-python/minimal/add_module.py b/examples/minimal/src-python/minimal/add_module.py
index 57e10fb..6487377 100644
--- a/examples/minimal/src-python/minimal/add_module.py
+++ b/examples/minimal/src-python/minimal/add_module.py
@@ -1 +1 @@
-from ._add_module import *
\ No newline at end of file
+from ._add_module import *  # noqa: F403
diff --git a/examples/minimal/src/CMakeLists.txt b/examples/minimal/src/CMakeLists.txt
index afca277..10af9fe 100644
--- a/examples/minimal/src/CMakeLists.txt
+++ b/examples/minimal/src/CMakeLists.txt
@@ -2,10 +2,10 @@ cmake_minimum_required(VERSION 3.17)
 project(minimal)
 
 # Find the Python development files
-find_package(Python3 REQUIRED COMPONENTS Development.Module)
+find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
 
 # Add the module to compile
-Python3_add_library(_add_module MODULE "add_module.c")
+Python3_add_library(_add_module MODULE "add_module.c" WITH_SOABI)
 
 # Install the module
 install(TARGETS _add_module
diff --git a/examples/minimal/src/_add_module.pyi b/examples/minimal/src/_add_module.pyi
index 7b2b623..a0c348f 100644
--- a/examples/minimal/src/_add_module.pyi
+++ b/examples/minimal/src/_add_module.pyi
@@ -1,3 +1,3 @@
 # Python stub file for the _add_module extension module
 
-def add(a: int, b: int) -> int: ...
\ No newline at end of file
+def add(a: int, b: int) -> int: ...
diff --git a/examples/minimal/test/test_add_module.py b/examples/minimal/tests/test_add_module.py
similarity index 98%
rename from examples/minimal/test/test_add_module.py
rename to examples/minimal/tests/test_add_module.py
index 890fda4..e8ce32d 100644
--- a/examples/minimal/test/test_add_module.py
+++ b/examples/minimal/tests/test_add_module.py
@@ -1,12 +1,15 @@
-from minimal.add_module import add
 import pytest
+from minimal.add_module import add
+
 
 def test_add_positive():
     assert add(1, 2) == 3
 
+
 def test_add_negative():
     assert add(1, -2) == -1
 
+
 def test_add_string():
     with pytest.raises(TypeError):
         add("foo", "bar")
diff --git a/examples/nanobind-project/.vscode/launch.json b/examples/nanobind-project/.vscode/launch.json
index ac7a3c0..4715ba9 100644
--- a/examples/nanobind-project/.vscode/launch.json
+++ b/examples/nanobind-project/.vscode/launch.json
@@ -50,4 +50,4 @@
             "preLaunchTask": "Install package (development)",
         },
     ]
-}
\ No newline at end of file
+}
diff --git a/examples/nanobind-project/.vscode/tasks.json b/examples/nanobind-project/.vscode/tasks.json
index 9f1cd40..66e57b4 100644
--- a/examples/nanobind-project/.vscode/tasks.json
+++ b/examples/nanobind-project/.vscode/tasks.json
@@ -13,4 +13,4 @@
             "group": "build"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/examples/nanobind-project/CMakeLists.txt b/examples/nanobind-project/CMakeLists.txt
index 95876c8..d271728 100644
--- a/examples/nanobind-project/CMakeLists.txt
+++ b/examples/nanobind-project/CMakeLists.txt
@@ -1,5 +1,5 @@
-cmake_minimum_required(VERSION 3.18...3.22)
-project(nanobind-project VERSION 0.1.8)
+cmake_minimum_required(VERSION 3.26)
+project(nanobind-project VERSION 0.3.0)
 set(PY_VERSION_SUFFIX "")
 set(PY_FULL_VERSION ${PROJECT_VERSION}${PY_VERSION_SUFFIX})
 
@@ -16,7 +16,7 @@ include(cmake/QueryPythonForNanobind.cmake)
 find_nanobind_python_first()
 
 # Compile the example Python module
-nanobind_add_module(_add_module "src/add_module.cpp")
+nanobind_add_module(_add_module STABLE_ABI "src/add_module.cpp")
 target_compile_definitions(_add_module PRIVATE
     MODULE_NAME=$<TARGET_FILE_BASE_NAME:_add_module>
     VERSION_INFO="${PY_FULL_VERSION}"
@@ -34,20 +34,22 @@ install(TARGETS _add_module
         EXCLUDE_FROM_ALL
         COMPONENT python_modules
         DESTINATION ${PY_BUILD_CMAKE_MODULE_NAME})
-# Install the debug file for the Python module (Windows only)
-if (WIN32)
-    install(FILES $<TARGET_PDB_FILE:_add_module>
-            EXCLUDE_FROM_ALL
-            COMPONENT python_modules
-            DESTINATION ${PY_BUILD_CMAKE_MODULE_NAME}
-            OPTIONAL)
-endif()
 
 # Generate stubs for the Python module
+set(WITH_PY_STUBS_DEFAULT On)
+if (CMAKE_CROSSCOMPILING)
+    set(WITH_PY_STUBS_DEFAULT Off)
+endif()
 option(WITH_PY_STUBS
-    "Generate Python stub files (.pyi) for the Python module." On)
-if (WITH_PY_STUBS AND NOT CMAKE_CROSSCOMPILING)
-    include(cmake/NanobindStubgen.cmake)
-    nanobind_stubgen(_add_module)
-    nanobind_stubgen_install(_add_module ${PY_BUILD_CMAKE_MODULE_NAME})
+    "Generate Python stub files (.pyi) for the Python module."
+    ${WITH_PY_STUBS_DEFAULT})
+if (WITH_PY_STUBS)
+    nanobind_add_stub(
+        $<TARGET_FILE_BASE_NAME:_add_module>_stub
+        INSTALL_TIME
+        COMPONENT python_modules
+        MODULE ${PY_BUILD_CMAKE_MODULE_NAME}.$<TARGET_FILE_BASE_NAME:_add_module>
+        OUTPUT ${PY_BUILD_CMAKE_MODULE_NAME}/$<TARGET_FILE_BASE_NAME:_add_module>.pyi
+        PYTHON_PATH "."
+    )
 endif()
diff --git a/examples/nanobind-project/cmake/NanobindStubgen.cmake b/examples/nanobind-project/cmake/NanobindStubgen.cmake
deleted file mode 100644
index b2a11e2..0000000
--- a/examples/nanobind-project/cmake/NanobindStubgen.cmake
+++ /dev/null
@@ -1,22 +0,0 @@
-function(nanobind_stubgen target)
-
-    find_package(Python REQUIRED COMPONENTS Interpreter)
-    add_custom_command(TARGET ${target} POST_BUILD
-        COMMAND ${Python_EXECUTABLE} -m nanobind_stubgen
-                --out $<TARGET_FILE_DIR:${target}>
-                $<TARGET_FILE_BASE_NAME:${target}>
-        WORKING_DIRECTORY $<TARGET_FILE_DIR:${target}>
-        USES_TERMINAL)
-
-endfunction()
-
-function(nanobind_stubgen_install target destination)
-
-    install(FILES
-        $<TARGET_FILE_DIR:${target}>/$<TARGET_FILE_BASE_NAME:${target}>.pyi
-        RENAME __init__.pyi
-        EXCLUDE_FROM_ALL
-        COMPONENT python_modules
-        DESTINATION ${destination}/$<TARGET_FILE_BASE_NAME:${target}>)
-
-endfunction()
\ No newline at end of file
diff --git a/examples/nanobind-project/cmake/QueryPythonForNanobind.cmake b/examples/nanobind-project/cmake/QueryPythonForNanobind.cmake
index edd027e..bf50911 100644
--- a/examples/nanobind-project/cmake/QueryPythonForNanobind.cmake
+++ b/examples/nanobind-project/cmake/QueryPythonForNanobind.cmake
@@ -1,19 +1,49 @@
 option(USE_GLOBAL_NANOBIND "Don't query Python to find nanobind" Off)
 mark_as_advanced(USE_GLOBAL_NANOBIND)
 
-# First tries to find Python 3, then tries to import the nanobind module to
+# Returns the parent folder of the current file.
+function(find_nanobind_python_first_dir var)
+    set(${var} ${CMAKE_CURRENT_FUNCTION_LIST_DIR} PARENT_SCOPE)
+endfunction()
+
+# First tries to find Python 3.8, then tries to import the nanobind module to
 # query the CMake config location, and finally imports nanobind using
-# find_package(nanobind REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH).
+# find_package(nanobind REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH). It also
+# allows setting (and fixing) NB_SUFFIX and NB_SUFFIX_S when cross-compiling.
+#
 # This is a macro rather than a function to make the variables set by
 # find_package(Python) available to the nanobind functions when called in the
 # main project (specifically, the nanobind_build_library function explicitly
-# adds the ${Python_INCLUDE_DIRS} to the nanobind include directories). It also
-# allows un-setting NB_SUFFIX when cross-compiling.
+# adds the ${Python_INCLUDE_DIRS} to the nanobind include directories).
 macro(find_nanobind_python_first)
 
-    find_package(Python 3.8 REQUIRED COMPONENTS Interpreter Development.Module)
-    if (NOT USE_GLOBAL_NANOBIND)
-        # Query Python to see if it knows where the headers are
+    # Find Python
+    if (CMAKE_CROSSCOMPILING AND NOT (APPLE AND "$ENV{CIBUILDWHEEL}" STREQUAL "1"))
+        find_package(Python 3.8 REQUIRED
+            COMPONENTS Development.Module
+            OPTIONAL_COMPONENTS Development.SABIModule)
+    else()
+        find_package(Python 3.8 REQUIRED
+            COMPONENTS Interpreter Development.Module
+            OPTIONAL_COMPONENTS Development.SABIModule)
+    endif()
+
+    # Tweak extension suffix and debug ABI when cross-compiling
+    if (CMAKE_CROSSCOMPILING AND NOT (DEFINED CACHE{NB_SUFFIX}
+                                      AND DEFINED CACHE{NB_SUFFIX_S}))
+        find_nanobind_python_first_dir(FNBF_CURRENT_DIR)
+        include(${FNBF_CURRENT_DIR}/nanobindGuessPythonExtSuffix.cmake)
+        nanobind_guess_python_module_extension(Python)
+    endif()
+    # Save for later ...
+    if (CMAKE_CROSSCOMPILING AND (DEFINED NB_SUFFIX
+                                  AND DEFINED NB_SUFFIX_S))
+        set(PY_BUILD_CMAKE_NB_SUFFIX "${NB_SUFFIX}" CACHE STRING "")
+        set(PY_BUILD_CMAKE_NB_SUFFIX_S "${NB_SUFFIX_S}" CACHE STRING "")
+    endif()
+
+    # Query Python to see if it knows where the pybind11 root is
+    if (NOT USE_GLOBAL_NANOBIND AND Python_EXECUTABLE)
         if (NOT nanobind_ROOT OR NOT EXISTS ${nanobind_ROOT})
             message(STATUS "Detecting nanobind CMake location")
             execute_process(COMMAND ${Python_EXECUTABLE}
@@ -36,45 +66,14 @@ macro(find_nanobind_python_first)
     # native version is fine
     find_package(nanobind ${ARGN} REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH)
 
-    # Tweak extension suffix when cross-compiling
-    if (CMAKE_CROSSCOMPILING)
-        if (NOT PY_BUILD_EXT_SUFFIX)
-            message(STATUS "Determining Python extension suffix")
-            # Find the python3.x-config script in the sysroot instead of on the
-            # build system:
-            find_program(PY_BUILD_Python_CONFIG
-                python${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}-config
-                ONLY_CMAKE_FIND_ROOT_PATH)
-            # Report errors:
-            if (NOT PY_BUILD_Python_CONFIG)
-                message(FATAL_ERROR "Unable to find python3-config."
-                    "\nTry manually setting PY_BUILD_EXT_SUFFIX.")
-            else()
-                # If we found the python3.x-config script, query it for the
-                # extension suffix:
-                execute_process(COMMAND ${PY_BUILD_Python_CONFIG}
-                    --extension-suffix
-                    OUTPUT_VARIABLE PY_BUILD_EXT_SUFFIX
-                    ERROR_VARIABLE PY_BUILD_EXT_SUFFIX_ERR
-                    OUTPUT_STRIP_TRAILING_WHITESPACE
-                    RESULT_VARIABLE PY_BUILD_EXT_SUFFIX_RESULT)
-                # Report errors:
-                if (NOT PY_BUILD_EXT_SUFFIX_RESULT EQUAL 0
-                    OR NOT PY_BUILD_EXT_SUFFIX)
-                    message(FATAL_ERROR "Unable to determine extension suffix:"
-                        "\n${PY_BUILD_EXT_SUFFIX}"
-                        "\n${PY_BUILD_EXT_SUFFIX_ERR}"
-                        "\nTry manually setting PY_BUILD_EXT_SUFFIX.")
-                endif()
-                # Cache the result:
-                set(PY_BUILD_EXT_SUFFIX ${PY_BUILD_EXT_SUFFIX} CACHE STRING
-                    "The extension for Python extension modules")
-            endif()
-        endif()
-        # Override nanobind-config.cmake's NB_SUFFIX variable:
-        message(STATUS "Python extension suffix: ${PY_BUILD_EXT_SUFFIX}")
+    # nanobind-config.cmake unconditionally sets these variables, but we want it
+    # to use our variables instead.
+    if (CMAKE_CROSSCOMPILING AND (DEFINED CACHE{PY_BUILD_CMAKE_NB_SUFFIX}
+                                  AND DEFINED CACHE{PY_BUILD_CMAKE_NB_SUFFIX_S}))
         unset(NB_SUFFIX)
-        set(NB_SUFFIX ${PY_BUILD_EXT_SUFFIX} CACHE INTERNAL "" FORCE)
+        unset(NB_SUFFIX_S)
+        set(NB_SUFFIX "$CACHE{PY_BUILD_CMAKE_NB_SUFFIX}" CACHE INTERNAL "")
+        set(NB_SUFFIX_S "$CACHE{PY_BUILD_CMAKE_NB_SUFFIX_S}" CACHE INTERNAL "")
     endif()
 
-endmacro()
\ No newline at end of file
+endmacro()
diff --git a/examples/nanobind-project/cmake/nanobindGuessPythonExtSuffix.cmake b/examples/nanobind-project/cmake/nanobindGuessPythonExtSuffix.cmake
new file mode 100644
index 0000000..c0db95b
--- /dev/null
+++ b/examples/nanobind-project/cmake/nanobindGuessPythonExtSuffix.cmake
@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.5)
+
+# Can be removed once https://github.com/pybind/pybind11/pull/5083 is merged
+
+function(nanobind_guess_python_module_extension python)
+
+  # The SETUPTOOLS_EXT_SUFFIX environment variable takes precedence:
+  if(NOT DEFINED PYTHON_MODULE_EXT_SUFFIX AND DEFINED ENV{SETUPTOOLS_EXT_SUFFIX})
+    message(
+      STATUS
+        "Getting Python extension suffix from ENV{SETUPTOOLS_EXT_SUFFIX}: $ENV{SETUPTOOLS_EXT_SUFFIX}"
+    )
+    set(PYTHON_MODULE_EXT_SUFFIX
+        "$ENV{SETUPTOOLS_EXT_SUFFIX}"
+        CACHE
+          STRING
+          "Extension suffix for Python extension modules (Initialized from SETUPTOOLS_EXT_SUFFIX)")
+  endif()
+  # If that didn't work, use the Python_SOABI variable:
+  if(NOT DEFINED PYTHON_MODULE_EXT_SUFFIX AND DEFINED ${python}_SOABI)
+    message(
+      STATUS "Determining Python extension suffix based on ${python}_SOABI: ${${python}_SOABI}")
+    # The final extension depends on the system
+    set(_PY_BUILD_EXTENSION "${CMAKE_SHARED_MODULE_SUFFIX}")
+    if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+      set(_PY_BUILD_EXTENSION ".pyd")
+    endif()
+    # If the SOABI already has an extension, use it as the full suffix
+    # (used for debug versions of Python on Windows)
+    if(${python}_SOABI MATCHES "\\.")
+      set(PYTHON_MODULE_EXT_SUFFIX "${${python}_SOABI}")
+    # If the SOABI is empty, this is usually a bug, but we generate a
+    # correct extension anyway, which is the best we can do
+    elseif("${${python}_SOABI}" STREQUAL "")
+      message(
+        WARNING
+          "${python}_SOABI is defined but empty. You may want to set PYTHON_MODULE_EXT_SUFFIX explicitly."
+      )
+      set(PYTHON_MODULE_EXT_SUFFIX "${_PY_BUILD_EXTENSION}")
+    # Otherwise, add the system-dependent extension to it
+    else()
+      set(PYTHON_MODULE_EXT_SUFFIX ".${${python}_SOABI}${_PY_BUILD_EXTENSION}")
+    endif()
+  endif()
+
+  # If we could not deduce the extension suffix, unset the results:
+  if(NOT DEFINED PYTHON_MODULE_EXT_SUFFIX)
+    unset(NB_SUFFIX PARENT_SCOPE)
+    unset(NB_SUFFIX_S PARENT_SCOPE)
+    return()
+  endif()
+
+  # Sanity checks:
+  if(${python}_SOABI AND NOT (PYTHON_MODULE_EXT_SUFFIX STREQUAL ${python}_SOABI
+                              OR PYTHON_MODULE_EXT_SUFFIX MATCHES "\\.${${python}_SOABI}\\."))
+    message(
+      WARNING
+        "Python extension suffix (${PYTHON_MODULE_EXT_SUFFIX}) does not match ${python}_SOABI (${${python}_SOABI})."
+    )
+  endif()
+
+  # Separate file name postfix from extension: (https://github.com/pybind/pybind11/issues/4699)
+  get_filename_component(_PYTHON_MODULE_DEBUG_POSTFIX "${PYTHON_MODULE_EXT_SUFFIX}" NAME_WE)
+  get_filename_component(_PYTHON_MODULE_EXTENSION "${PYTHON_MODULE_EXT_SUFFIX}" EXT)
+  get_filename_component(_PYTHON_MODULE_EXTENSION_EXT "${PYTHON_MODULE_EXT_SUFFIX}" LAST_EXT)
+
+  # Try to deduce the debug ABI from the extension suffix:
+  if(NOT DEFINED _PYTHON_IS_DEBUG)
+    if(_PYTHON_MODULE_EXTENSION MATCHES "^\\.(cpython-|cp|pypy)[0-9]+dm?-"
+       OR _PYTHON_MODULE_DEBUG_POSTFIX MATCHES "^_d")
+      set(_PYTHON_IS_DEBUG On)
+    else()
+      set(_PYTHON_IS_DEBUG Off)
+    endif()
+  endif()
+
+  # Return results
+  set(NB_SUFFIX
+      "${_PYTHON_MODULE_DEBUG_POSTFIX}${_PYTHON_MODULE_EXTENSION}"
+      PARENT_SCOPE)
+  set(NB_SUFFIX_S
+      ".abi3${_PYTHON_MODULE_EXTENSION_EXT}"
+      PARENT_SCOPE)
+
+endfunction()
diff --git a/examples/nanobind-project/cross-compile-linux.sh b/examples/nanobind-project/cross-compile-linux.sh
new file mode 100755
index 0000000..8e7aa82
--- /dev/null
+++ b/examples/nanobind-project/cross-compile-linux.sh
@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+
+# This script cross-compiles the Python package for a range of popular
+# architectures (x86-64, ARMv6, ARMv7, ARMv8-64) and all current versions of
+# CPython and PyPy.
+#
+# You should first download the cross-compilation toolchains
+# (https://github.com/tttapa/toolchains) and the Python libraries for the given
+# architecture (https://github.com/tttapa/python-dev). This is done by running
+# the ../../scripts/download-cross-toolchains-linux.sh script.
+#
+# These toolchains include CMake toolchain files and configuration files for
+# py-build-cmake ({triple}.{python_version}.py-build-cmake cross.toml). When
+# these configuration files are passed using the -C cross flag, it will
+# cause py-build-cmake to cross-compile the package for the given architecture
+# and Python version (which may be different from the architecture and version
+# of the Python interpreter that is used to drive the build process).
+#
+# The resulting Python Wheel packages can be found in the dist directory.
+#
+# See https://tttapa.github.io/py-build-cmake/Cross-compilation.html for more
+# information about cross-compilation.
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+# Select the architectures and Python versions to build for.
+triples=(x86_64-bionic-linux-gnu armv6-rpi-linux-gnueabihf armv7-neon-linux-gnueabihf aarch64-rpi3-linux-gnu)
+python_versions=("python3.8" "python3.9" "python3.10" "python3.11" "python3.12" "python3.13")
+pypy_triples=(x86_64-bionic-linux-gnu aarch64-rpi3-linux-gnu)
+pypy_versions=("pypy3.8-v7.3" "pypy3.9-v7.3" "pypy3.10-v7.3")
+
+# Ensure that the necessary toolchains are available.
+toolchain_folder="$PWD/../../toolchains"
+if [ ! -d "$toolchain_folder/x-tools" ]; then
+    echo "Cross-compilation toolchains not found."
+    echo "Please run \"$(realpath "$PWD/../../scripts/download-cross-toolchains-linux.sh")\" first."
+    exit 1
+fi
+
+set -ex
+
+# Install PyPA build
+python3 -m pip install --quiet --no-warn-script-location -U pip build
+
+# Link the C++ standard library statically to support systems that have an
+# older version installed. Same for the GCC runtime library (libgcc).
+export LDFLAGS="-static-libgcc -static-libstdc++"
+
+# Cross-compile the package for CPython.
+for triple in ${triples[@]}; do
+    for python_version in ${python_versions[@]}; do
+        rm -rf .py-build-cmake_cache
+        python3 -m build . -w \
+            -C cross="$toolchain_folder/x-tools/$triple.$python_version.py-build-cmake.cross.toml"
+    done
+done
+
+# Cross-compile the package for PyPy.
+for triple in ${pypy_triples[@]}; do
+    for python_version in ${pypy_versions[@]}; do
+        rm -rf .py-build-cmake_cache
+        python3 -m build . -w \
+            -C cross="$toolchain_folder/x-tools/$triple.$python_version.py-build-cmake.cross.toml"
+    done
+done
diff --git a/examples/nanobind-project/examples/add_example.py b/examples/nanobind-project/examples/add_example.py
index 042ee2a..1cc247b 100644
--- a/examples/nanobind-project/examples/add_example.py
+++ b/examples/nanobind-project/examples/add_example.py
@@ -3,4 +3,4 @@
 a = 1
 b = 2
 c = add(a, b)
-print(f'{a} + {b} = {c}')
\ No newline at end of file
+print(f"{a} + {b} = {c}")
diff --git a/examples/nanobind-project/py-build-cmake.cross.example.toml b/examples/nanobind-project/py-build-cmake.cross.example.toml
deleted file mode 100644
index 485d4ad..0000000
--- a/examples/nanobind-project/py-build-cmake.cross.example.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-# This file shows how to cross-compile the module.
-#
-# Rename it to py-build-cmake.cross.toml, and edit the settings to match your
-# setup. Then edit the CMake toolchain file as well, so that it selects the
-# right compiler and sets the sysroot to point to a root filesystem folder
-# containing a Python installation.
-#
-# Note that py-build-cmake cannot check that the Python version used by CMake
-# matches the version and ABI specified here. It is therefore a good idea to
-# hardcode the paths to the Python headers and library, either in your CMake
-# toolchain file, or in this file, as shown below.
-#
-# For more information about cross-compilation, see
-# https://tttapa.github.io/py-build-cmake/Cross-compilation.html and
-# https://tttapa.github.io/Pages/Raspberry-Pi/C++-Development-RPiOS/index.html.
-
-implementation = 'cp'
-version = '39'
-abi = 'cp39'
-arch = 'linux_aarch64'
-toolchain_file = 'aarch64-rpi3-linux-gnu.cmake'
-copy_from_native_build = ['nanobind_project/*.pyi']
-
-[cmake]
-generator = 'Ninja Multi-Config'
-config = ["Debug", "Release"]
-
-[cmake.options]
-Python3_LIBRARY = "/path-to-sysroot/usr/lib/aarch64-linux-gnu/libpython3.9.so"
-Python3_INCLUDE_DIR = "/path-to-sysroot/usr/include/python3.9"
-CMAKE_DEBUG_POSTFIX = '_d'
\ No newline at end of file
diff --git a/examples/nanobind-project/pyproject.toml b/examples/nanobind-project/pyproject.toml
index b1d59cb..1de3678 100644
--- a/examples/nanobind-project/pyproject.toml
+++ b/examples/nanobind-project/pyproject.toml
@@ -4,7 +4,7 @@ readme = "README.md"
 requires-python = ">=3.8"
 license = { "file" = "LICENSE" }
 authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
-keywords = ["addition", "subtraction", "nanobind"]
+keywords = ["example", "addition", "subtraction", "nanobind"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "License :: OSI Approved :: MIT License",
@@ -13,6 +13,8 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: MacOS",
@@ -25,7 +27,11 @@ dynamic = ["version", "description"]
 add = "nanobind_project.add:main"
 
 [build-system]
-requires = ["py-build-cmake~=0.1.8", "nanobind~=1.1.0", "nanobind-stubgen~=0.1.1"]
+requires = [
+    "py-build-cmake~=0.3.0",
+    "nanobind~=2.2.0",
+    "typing_extensions~=4.12.2; python_version < '3.11'",
+]
 build-backend = "py_build_cmake.build"
 
 [tool.py-build-cmake.module]
@@ -37,17 +43,21 @@ include = ["CMakeLists.txt", "cmake/*.cmake", "src/*.cpp", "src/*.hpp"]
 exclude = []
 
 [tool.py-build-cmake.cmake]
-minimum_version = "3.18"
+minimum_version = "3.26"
 build_type = "Release"
 source_path = "." # Containing CMakeLists.txt
-options = { "WITH_PY_STUBS:BOOL" = "On" }
+options = {}
 args = ["-Wdev"]
+find_python3 = false
 find_python = true
 build_args = ["-j"]
 build_tool_args = []
 install_args = ["--verbose"]
 install_components = ["python_modules"]
 env = {}
+[tool.py-build-cmake.wheel]
+python_abi = 'abi3'
+abi3_minimum_cpython_version = 312
 
 [tool.py-build-cmake.linux.cmake] # Linux-specific options
 generator = "Ninja Multi-Config"
@@ -71,5 +81,4 @@ CMAKE_RELWITHDEBINFO_POSTFIX = "_d"
 args = ["-v"]
 
 [tool.pytest.ini_options]
-minversion = "6.0"
-testpaths = ["test"]
+testpaths = ["tests"]
diff --git a/examples/nanobind-project/python-src/nanobind_project/__init__.py b/examples/nanobind-project/python-src/nanobind_project/__init__.py
index ec9386f..959b475 100644
--- a/examples/nanobind-project/python-src/nanobind_project/__init__.py
+++ b/examples/nanobind-project/python-src/nanobind_project/__init__.py
@@ -1,2 +1,3 @@
 """Example project using the py-build-cmake build backend and nanobind."""
-__version__ = '0.1.8'
\ No newline at end of file
+
+__version__ = "0.3.0"
diff --git a/examples/nanobind-project/python-src/nanobind_project/add.py b/examples/nanobind-project/python-src/nanobind_project/add.py
index c2444ef..3291e84 100644
--- a/examples/nanobind-project/python-src/nanobind_project/add.py
+++ b/examples/nanobind-project/python-src/nanobind_project/add.py
@@ -1,6 +1,8 @@
-from .add_module import add
 import sys
 
+from .add_module import add
+
+
 def main():
     """Script that adds all command line arguments as integers."""
     sum = 0
diff --git a/examples/nanobind-project/python-src/nanobind_project/add_module.py b/examples/nanobind-project/python-src/nanobind_project/add_module.py
index bd8879f..9a05f40 100644
--- a/examples/nanobind-project/python-src/nanobind_project/add_module.py
+++ b/examples/nanobind-project/python-src/nanobind_project/add_module.py
@@ -2,9 +2,10 @@
 
 import os
 import typing
-if not typing.TYPE_CHECKING and os.getenv('NANOBIND_PROJECT_PYTHON_DEBUG'):
-    from ._add_module_d import *
-    from ._add_module_d import __version__
+
+if not typing.TYPE_CHECKING and os.getenv("NANOBIND_PROJECT_PYTHON_DEBUG"):
+    from ._add_module_d import *  # noqa: F403
+    from ._add_module_d import __version__  # noqa: F401, RUF100
 else:
-    from ._add_module import *
-    from ._add_module import __version__
+    from ._add_module import *  # noqa: F403
+    from ._add_module import __version__  # noqa: F401, RUF100
diff --git a/examples/nanobind-project/python-src/nanobind_project/sub_package/__init__.py b/examples/nanobind-project/python-src/nanobind_project/sub_package/__init__.py
index d0a82d3..bc7e6aa 100644
--- a/examples/nanobind-project/python-src/nanobind_project/sub_package/__init__.py
+++ b/examples/nanobind-project/python-src/nanobind_project/sub_package/__init__.py
@@ -1,2 +1,6 @@
-"""Example package that subtracts two integers in Python."""
-from .sub import *
\ No newline at end of file
+"""Example module that subtracts two integers in Python."""
+
+
+def sub(a: int, b: int) -> int:
+    """Subtracts two integers"""
+    return a - b
diff --git a/examples/nanobind-project/test/test_add_module.py b/examples/nanobind-project/tests/test_add_module.py
similarity index 88%
rename from examples/nanobind-project/test/test_add_module.py
rename to examples/nanobind-project/tests/test_add_module.py
index db847b8..887c91d 100644
--- a/examples/nanobind-project/test/test_add_module.py
+++ b/examples/nanobind-project/tests/test_add_module.py
@@ -1,4 +1,8 @@
 from importlib.metadata import version
+
+from nanobind_project import __version__ as py_version
+from nanobind_project._add_module import __version__ as cpp_version
+from nanobind_project.add_module import __version__ as py_cpp_version
 from nanobind_project.add_module import add
 
 
@@ -6,12 +10,7 @@ def test_add():
     assert add(1, 2) == 3
 
 
-from nanobind_project import __version__ as py_version
-from nanobind_project.add_module import __version__ as py_cpp_version
-from nanobind_project._add_module import __version__ as cpp_version
-
-
 def test_version():
     assert py_version == py_cpp_version
     assert py_version == cpp_version
-    assert py_version == version('nanobind_project')
+    assert py_version == version("nanobind_project")
diff --git a/examples/nanobind-project/test/test_sub_package.py b/examples/nanobind-project/tests/test_sub_package.py
similarity index 98%
rename from examples/nanobind-project/test/test_sub_package.py
rename to examples/nanobind-project/tests/test_sub_package.py
index 27b39d7..31d4cd2 100644
--- a/examples/nanobind-project/test/test_sub_package.py
+++ b/examples/nanobind-project/tests/test_sub_package.py
@@ -1,4 +1,5 @@
 from nanobind_project.sub_package import sub
 
+
 def test_sub():
     assert sub(3, 2) == 1
diff --git a/examples/pybind11-project/.vscode/launch.json b/examples/pybind11-project/.vscode/launch.json
index 4c85e82..bb0284e 100644
--- a/examples/pybind11-project/.vscode/launch.json
+++ b/examples/pybind11-project/.vscode/launch.json
@@ -50,4 +50,4 @@
             "preLaunchTask": "Install package (development)",
         },
     ]
-}
\ No newline at end of file
+}
diff --git a/examples/pybind11-project/.vscode/tasks.json b/examples/pybind11-project/.vscode/tasks.json
index 9f1cd40..66e57b4 100644
--- a/examples/pybind11-project/.vscode/tasks.json
+++ b/examples/pybind11-project/.vscode/tasks.json
@@ -13,4 +13,4 @@
             "group": "build"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/examples/pybind11-project/CMakeLists.txt b/examples/pybind11-project/CMakeLists.txt
index 2e94ada..a42163b 100644
--- a/examples/pybind11-project/CMakeLists.txt
+++ b/examples/pybind11-project/CMakeLists.txt
@@ -1,5 +1,5 @@
-cmake_minimum_required(VERSION 3.17)
-project(pybind11-project VERSION 0.1.8)
+cmake_minimum_required(VERSION 3.18)
+project(pybind11-project VERSION 0.3.0)
 set(PY_VERSION_SUFFIX "")
 set(PY_FULL_VERSION ${PROJECT_VERSION}${PY_VERSION_SUFFIX})
 
@@ -11,12 +11,21 @@ if (DEFINED PY_BUILD_CMAKE_PACKAGE_VERSION)
     endif()
 endif()
 
+# Find the Python interpreter and the development files
+if (CMAKE_CROSSCOMPILING AND NOT (APPLE AND "$ENV{CIBUILDWHEEL}" STREQUAL "1"))
+    find_package(Python3 REQUIRED COMPONENTS Development.Module)
+else()
+    find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
+endif()
+
 # Find the pybind11 package
 include(cmake/QueryPythonForPybind11.cmake)
 find_pybind11_python_first()
 
 # Compile the example Python module
 pybind11_add_module(_add_module MODULE "src/add_module.cpp")
+set_target_properties(_add_module PROPERTIES
+    DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}${PYTHON_MODULE_DEBUG_POSTFIX}")
 target_compile_definitions(_add_module PRIVATE
     MODULE_NAME=$<TARGET_FILE_BASE_NAME:_add_module>
     VERSION_INFO="${PY_FULL_VERSION}"
@@ -34,20 +43,18 @@ install(TARGETS _add_module
         EXCLUDE_FROM_ALL
         COMPONENT python_modules
         DESTINATION ${PY_BUILD_CMAKE_MODULE_NAME})
-# Install the debug file for the Python module (Windows only)
-if (WIN32)
-    install(FILES $<TARGET_PDB_FILE:_add_module>
-            EXCLUDE_FROM_ALL
-            COMPONENT python_modules
-            DESTINATION ${PY_BUILD_CMAKE_MODULE_NAME}
-            OPTIONAL)
-endif()
 
 # Generate stubs for the Python module
+set(WITH_PY_STUBS_DEFAULT On)
+if (CMAKE_CROSSCOMPILING)
+    set(WITH_PY_STUBS_DEFAULT Off)
+endif()
 option(WITH_PY_STUBS
-    "Generate Python stub files (.pyi) for the Python module." On)
-if (WITH_PY_STUBS AND NOT CMAKE_CROSSCOMPILING)
+    "Generate Python stub files (.pyi) for the Python module."
+    ${WITH_PY_STUBS_DEFAULT})
+if (WITH_PY_STUBS)
     include(cmake/Pybind11Stubgen.cmake)
-    pybind11_stubgen(_add_module)
-    pybind11_stubgen_install(_add_module ${PY_BUILD_CMAKE_MODULE_NAME})
+    pybind11_stubgen(_add_module
+        PACKAGE ${PY_BUILD_CMAKE_MODULE_NAME}
+        COMPONENT python_stubs)
 endif()
diff --git a/examples/pybind11-project/aarch64-rpi3-linux-gnu.cmake b/examples/pybind11-project/aarch64-rpi3-linux-gnu.cmake
deleted file mode 100644
index bde1a9b..0000000
--- a/examples/pybind11-project/aarch64-rpi3-linux-gnu.cmake
+++ /dev/null
@@ -1,28 +0,0 @@
-# For more information, see 
-# https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html and
-# https://tttapa.github.io/Pages/Raspberry-Pi/C++-Development-RPiOS/index.html.
-
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
-
-set(CMAKE_SYSROOT /var/lib/schroot/chroots/rpi3-impish-arm64)
-SET(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) 
-set(CMAKE_LIBRARY_ARCHITECTURE aarch64-linux-gnu)
-set(CMAKE_STAGING_PREFIX $ENV{HOME}/RPi-dev/staging-aarch64-rpi3)
-
-set(cross "aarch64-rpi3-linux-gnu")
-set(CMAKE_C_COMPILER ${cross}-gcc)
-set(CMAKE_CXX_COMPILER ${cross}-g++)
-set(CMAKE_Fortran_COMPILER ${cross}-gfortran)
-
-set(ARCH_FLAGS "-mcpu=cortex-a53+crc+simd")
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARCH_FLAGS}")
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARCH_FLAGS}")
-SET(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${ARCH_FLAGS}")
-
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
-
-set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE arm64)
diff --git a/examples/pybind11-project/cmake/Pybind11Stubgen.cmake b/examples/pybind11-project/cmake/Pybind11Stubgen.cmake
index 225d5d0..96a7eb4 100644
--- a/examples/pybind11-project/cmake/Pybind11Stubgen.cmake
+++ b/examples/pybind11-project/cmake/Pybind11Stubgen.cmake
@@ -1,24 +1,29 @@
 function(pybind11_stubgen target)
 
-    find_package(Python3 REQUIRED COMPONENTS Interpreter)
-    add_custom_command(TARGET ${target} POST_BUILD
-        COMMAND ${Python3_EXECUTABLE} -m pybind11_stubgen
-                $<TARGET_FILE_BASE_NAME:${target}>
-                --bare-numpy-ndarray
-                --no-setup-py
-                -o $<TARGET_FILE_DIR:${target}>
-        WORKING_DIRECTORY $<TARGET_FILE_DIR:${target}>
-        USES_TERMINAL)
+    cmake_parse_arguments(STUBGEN "" "PACKAGE;DESTINATION;COMPONENT" "" ${ARGN})
+    if (NOT DEFINED STUBGEN_PACKAGE)
+        set(STUBGEN_PACKAGE ${PY_BUILD_CMAKE_MODULE_NAME})
+    endif()
+    if (NOT DEFINED STUBGEN_DESTINATION)
+        set(STUBGEN_DESTINATION "")
+    endif()
+    if (NOT DEFINED STUBGEN_COMPONENT)
+        set(STUBGEN_COMPONENT "python_stubs")
+    endif()
 
-endfunction()
-
-function(pybind11_stubgen_install target destination)
+    if (NOT DEFINED Python3_EXECUTABLE)
+        find_package(Python3 REQUIRED COMPONENTS Interpreter)
+    endif()
 
-    install(DIRECTORY
-        $<TARGET_FILE_DIR:${target}>/$<TARGET_FILE_BASE_NAME:${target}>-stubs/
-        EXCLUDE_FROM_ALL
-        COMPONENT python_modules
-        DESTINATION ${destination}/$<TARGET_FILE_BASE_NAME:${target}>
-        FILES_MATCHING REGEX "\.pyi$")
+    set(STUBGEN_MODULE ${STUBGEN_PACKAGE}.$<TARGET_FILE_BASE_NAME:${target}>)
+    set(STUBGEN_CMD "\"${Python3_EXECUTABLE}\" -m pybind11_stubgen -o . --exit-code \"${STUBGEN_MODULE}\"")
+    install(CODE "
+        execute_process(COMMAND ${STUBGEN_CMD}
+                        WORKING_DIRECTORY \"\${CMAKE_INSTALL_PREFIX}/${STUBGEN_DESTINATION}\"
+                        RESULT_VARIABLE STUBGEN_RET)
+        if(NOT STUBGEN_RET EQUAL 0)
+            message(SEND_ERROR \"pybind11-stubgen ${STUBGEN_MODULE} failed.\")
+        endif()
+        " EXCLUDE_FROM_ALL COMPONENT ${STUBGEN_COMPONENT})
 
-endfunction()
\ No newline at end of file
+endfunction()
diff --git a/examples/pybind11-project/cmake/QueryPythonForPybind11.cmake b/examples/pybind11-project/cmake/QueryPythonForPybind11.cmake
index c09bca3..93b278b 100644
--- a/examples/pybind11-project/cmake/QueryPythonForPybind11.cmake
+++ b/examples/pybind11-project/cmake/QueryPythonForPybind11.cmake
@@ -1,69 +1,43 @@
+option(USE_GLOBAL_PYBIND11 "Don't query Python to find pybind11" Off)
+mark_as_advanced(USE_GLOBAL_PYBIND11)
+
 # First tries to find Python 3, then tries to import the pybind11 module to
 # query the CMake config location, and finally imports pybind11 using
-# find_package(pybind11 REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH).
-function(find_pybind11_python_first)
+# find_package(pybind11 ${ARGN} REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH),
+# where ${ARGN} are the arguments passed to this macro.
+macro(find_pybind11_python_first)
 
-    # Query Python to see if it knows where the headers are
-    find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
-    if (NOT pybind11_ROOT OR NOT EXISTS ${pybind11_ROOT})
-        message(STATUS "Detecting pybind11 CMake location")
-        execute_process(COMMAND ${Python3_EXECUTABLE}
-                -m pybind11 --cmakedir
-            OUTPUT_VARIABLE PY_BUILD_PYBIND11_ROOT
-            OUTPUT_STRIP_TRAILING_WHITESPACE
-            RESULT_VARIABLE PY_BUILD_CMAKE_PYBIND11_RESULT)
-        # If it was successful
-        if (PY_BUILD_CMAKE_PYBIND11_RESULT EQUAL 0)
-            message(STATUS "pybind11 CMake location: ${PY_BUILD_PYBIND11_ROOT}")
-            set(pybind11_ROOT ${PY_BUILD_PYBIND11_ROOT}
-                CACHE PATH "Path to the pybind11 CMake configuration." FORCE)
-        else()
-            unset(pybind11_ROOT CACHE)
-        endif()
-    endif()
+    # https://github.com/pybind/pybind11/pull/5083
+    set(PYBIND11_USE_CROSSCOMPILING On)
 
-    # pybind11 is header-only, so finding a native version is fine
-    find_package(pybind11 ${ARGN} REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH)
+    # Find Python
+    if (CMAKE_CROSSCOMPILING AND NOT (APPLE AND "$ENV{CIBUILDWHEEL}" STREQUAL "1"))
+        find_package(Python3 REQUIRED COMPONENTS Development.Module)
+    else()
+        find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
+    endif()
 
-    # Tweak extension suffix when cross-compiling
-    if (CMAKE_CROSSCOMPILING)
-        if (NOT PY_BUILD_EXT_SUFFIX)
-            message(STATUS "Determining Python extension suffix")
-            # Find the python3.x-config script in the sysroot instead of on the
-            # build system:
-            find_program(PY_BUILD_Python3_CONFIG
-                python${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR}-config
-                ONLY_CMAKE_FIND_ROOT_PATH)
-            # Report errors:
-            if (NOT PY_BUILD_Python3_CONFIG)
-                message(FATAL_ERROR "Unable to find python3-config."
-                    "\nTry manually setting PY_BUILD_EXT_SUFFIX.")
+    # Query Python to see if it knows where the pybind11 root is
+    if (NOT USE_GLOBAL_PYBIND11 AND Python3_EXECUTABLE)
+        if (NOT pybind11_ROOT OR NOT EXISTS ${pybind11_ROOT})
+            message(STATUS "Detecting pybind11 CMake location")
+            execute_process(COMMAND ${Python3_EXECUTABLE}
+                    -m pybind11 --cmakedir
+                OUTPUT_VARIABLE PY_BUILD_PYBIND11_ROOT
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                RESULT_VARIABLE PY_BUILD_CMAKE_PYBIND11_RESULT)
+            # If it was successful
+            if (PY_BUILD_CMAKE_PYBIND11_RESULT EQUAL 0)
+                message(STATUS "pybind11 CMake location: ${PY_BUILD_PYBIND11_ROOT}")
+                set(pybind11_ROOT ${PY_BUILD_PYBIND11_ROOT}
+                    CACHE PATH "Path to the pybind11 CMake configuration." FORCE)
             else()
-                # If we found the python3.x-config script, query it for the
-                # extension suffix:
-                execute_process(COMMAND ${PY_BUILD_Python3_CONFIG}
-                    --extension-suffix
-                    OUTPUT_VARIABLE PY_BUILD_EXT_SUFFIX
-                    ERROR_VARIABLE PY_BUILD_EXT_SUFFIX_ERR
-                    OUTPUT_STRIP_TRAILING_WHITESPACE
-                    RESULT_VARIABLE PY_BUILD_EXT_SUFFIX_RESULT)
-                # Report errors:
-                if (NOT PY_BUILD_EXT_SUFFIX_RESULT EQUAL 0
-                    OR NOT PY_BUILD_EXT_SUFFIX)
-                    message(FATAL_ERROR "Unable to determine extension suffix:"
-                        "\n${PY_BUILD_EXT_SUFFIX}"
-                        "\n${PY_BUILD_EXT_SUFFIX_ERR}"
-                        "\nTry manually setting PY_BUILD_EXT_SUFFIX.")
-                endif()
-                # Cache the result:
-                set(PY_BUILD_EXT_SUFFIX ${PY_BUILD_EXT_SUFFIX} CACHE STRING
-                    "The extension for Python extension modules")
+                unset(pybind11_ROOT CACHE)
             endif()
         endif()
-        # Override pybind11NewTools.cmake's PYTHON_MODULE_EXTENSION variable:
-        message(STATUS "Python extension suffix: ${PY_BUILD_EXT_SUFFIX}")
-        set(PYTHON_MODULE_EXTENSION ${PY_BUILD_EXT_SUFFIX}
-            CACHE INTERNAL "" FORCE)
     endif()
 
-endfunction()
\ No newline at end of file
+    # pybind11 is header-only, so finding a native version is fine
+    find_package(pybind11 ${ARGN} REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH)
+
+endmacro()
diff --git a/examples/pybind11-project/cross-compile-linux.sh b/examples/pybind11-project/cross-compile-linux.sh
new file mode 100755
index 0000000..118e845
--- /dev/null
+++ b/examples/pybind11-project/cross-compile-linux.sh
@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+
+# This script cross-compiles the Python package for a range of popular
+# architectures (x86-64, ARMv6, ARMv7, ARMv8-64) and all current versions of
+# CPython and PyPy.
+#
+# You should first download the cross-compilation toolchains
+# (https://github.com/tttapa/toolchains) and the Python libraries for the given
+# architecture (https://github.com/tttapa/python-dev). This is done by running
+# the ../../scripts/download-cross-toolchains-linux.sh script.
+#
+# These toolchains include CMake toolchain files and configuration files for
+# py-build-cmake ({triple}.{python_version}.py-build-cmake cross.toml). When
+# these configuration files are passed using the -C cross flag, it will
+# cause py-build-cmake to cross-compile the package for the given architecture
+# and Python version (which may be different from the architecture and version
+# of the Python interpreter that is used to drive the build process).
+#
+# The resulting Python Wheel packages can be found in the dist directory.
+#
+# See https://tttapa.github.io/py-build-cmake/Cross-compilation.html for more
+# information about cross-compilation.
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+# Select the architectures and Python versions to build for.
+triples=(x86_64-bionic-linux-gnu armv6-rpi-linux-gnueabihf armv7-neon-linux-gnueabihf aarch64-rpi3-linux-gnu)
+python_versions=("python3.7" "python3.8" "python3.9" "python3.10" "python3.11" "python3.12" "python3.13")
+pypy_triples=(x86_64-bionic-linux-gnu aarch64-rpi3-linux-gnu)
+pypy_versions=("pypy3.7-v7.3" "pypy3.8-v7.3" "pypy3.9-v7.3" "pypy3.10-v7.3")
+
+# Ensure that the necessary toolchains are available.
+toolchain_folder="$PWD/../../toolchains"
+if [ ! -d "$toolchain_folder/x-tools" ]; then
+    echo "Cross-compilation toolchains not found."
+    echo "Please run \"$(realpath "$PWD/../../scripts/download-cross-toolchains-linux.sh")\" first."
+    exit 1
+fi
+
+set -ex
+
+# Install PyPA build
+python3 -m pip install --quiet --no-warn-script-location -U pip build
+
+# Link the C++ standard library statically to support systems that have an
+# older version installed. Same for the GCC runtime library (libgcc).
+export LDFLAGS="-static-libgcc -static-libstdc++"
+
+# Cross-compile the package for CPython.
+for triple in ${triples[@]}; do
+    for python_version in ${python_versions[@]}; do
+        rm -rf .py-build-cmake_cache
+        python3 -m build . -w \
+            -C cross="$toolchain_folder/x-tools/$triple.$python_version.py-build-cmake.cross.toml"
+    done
+done
+
+# Cross-compile the package for PyPy.
+for triple in ${pypy_triples[@]}; do
+    for python_version in ${pypy_versions[@]}; do
+        rm -rf .py-build-cmake_cache
+        python3 -m build . -w \
+            -C cross="$toolchain_folder/x-tools/$triple.$python_version.py-build-cmake.cross.toml"
+    done
+done
diff --git a/examples/pybind11-project/examples/add_example.py b/examples/pybind11-project/examples/add_example.py
index eaf94fd..5df9bb8 100644
--- a/examples/pybind11-project/examples/add_example.py
+++ b/examples/pybind11-project/examples/add_example.py
@@ -3,4 +3,4 @@
 a = 1
 b = 2
 c = add(a, b)
-print(f'{a} + {b} = {c}')
\ No newline at end of file
+print(f"{a} + {b} = {c}")
diff --git a/examples/pybind11-project/py-build-cmake.cross.example.toml b/examples/pybind11-project/py-build-cmake.cross.example.toml
deleted file mode 100644
index 3257814..0000000
--- a/examples/pybind11-project/py-build-cmake.cross.example.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-# This file shows how to cross-compile the module.
-#
-# Rename it to py-build-cmake.cross.toml, and edit the settings to match your
-# setup. Then edit the CMake toolchain file as well, so that it selects the
-# right compiler and sets the sysroot to point to a root filesystem folder
-# containing a Python installation.
-#
-# Note that py-build-cmake cannot check that the Python version used by CMake
-# matches the version and ABI specified here. It is therefore a good idea to
-# hardcode the paths to the Python headers and library, either in your CMake
-# toolchain file, or in this file, as shown below.
-#
-# For more information about cross-compilation, see
-# https://tttapa.github.io/py-build-cmake/Cross-compilation.html and
-# https://tttapa.github.io/Pages/Raspberry-Pi/C++-Development-RPiOS/index.html.
-
-implementation = 'cp'
-version = '39'
-abi = 'cp39'
-arch = 'linux_aarch64'
-toolchain_file = 'aarch64-rpi3-linux-gnu.cmake'
-copy_from_native_build = ['pybind11_project/*.pyi']
-
-[cmake]
-generator = 'Ninja Multi-Config'
-config = ["Debug", "Release"]
-
-[cmake.options]
-Python3_LIBRARY = "/path-to-sysroot/usr/lib/aarch64-linux-gnu/libpython3.9.so"
-Python3_INCLUDE_DIR = "/path-to-sysroot/usr/include/python3.9"
-CMAKE_DEBUG_POSTFIX = '_d'
\ No newline at end of file
diff --git a/examples/pybind11-project/pyproject.toml b/examples/pybind11-project/pyproject.toml
index 04d242c..4f69809 100644
--- a/examples/pybind11-project/pyproject.toml
+++ b/examples/pybind11-project/pyproject.toml
@@ -4,7 +4,7 @@ readme = "README.md"
 requires-python = ">=3.7"
 license = { "file" = "LICENSE" }
 authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
-keywords = ["addition", "subtraction", "pybind11"]
+keywords = ["example", "addition", "subtraction", "pybind11"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "License :: OSI Approved :: MIT License",
@@ -14,6 +14,8 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: MacOS",
@@ -25,8 +27,15 @@ dynamic = ["version", "description"]
 [project.scripts]
 add = "pybind11_project.add:main"
 
+[project.optional-dependencies]
+test = ["pytest>=7.2.0,<7.5"]
+
 [build-system]
-requires = ["py-build-cmake~=0.1.8", "pybind11", "pybind11-stubgen"]
+requires = [
+    "py-build-cmake~=0.3.0",
+    "pybind11~=2.13.6",
+    "pybind11-stubgen~=2.5.1",
+]
 build-backend = "py_build_cmake.build"
 
 [tool.py-build-cmake.module]
@@ -38,15 +47,15 @@ include = ["CMakeLists.txt", "cmake/*.cmake", "src/*.cpp", "src/*.hpp"]
 exclude = []
 
 [tool.py-build-cmake.cmake]
-minimum_version = "3.17"
+minimum_version = "3.18"
 build_type = "Release"
 source_path = "." # Containing CMakeLists.txt
-options = { "WITH_PY_STUBS:BOOL" = "On" }
+options = {}
 args = ["-Wdev"]
 build_args = ["-j"]
 build_tool_args = []
 install_args = ["--verbose"]
-install_components = ["python_modules"]
+install_components = ["python_modules", "python_stubs"]
 env = {}
 
 [tool.py-build-cmake.linux.cmake] # Linux-specific options
@@ -71,5 +80,10 @@ CMAKE_RELWITHDEBINFO_POSTFIX = "_d"
 args = ["-v"]
 
 [tool.pytest.ini_options]
-minversion = "6.0"
-testpaths = ["test"]
+testpaths = ["tests"]
+
+[tool.cibuildwheel]
+build-verbosity = 1
+environment = { PY_BUILD_CMAKE_VERBOSE="1" }
+test-command = "pytest {package}/tests"
+test-extras = ["test"]
diff --git a/examples/pybind11-project/python-src/pybind11_project/__init__.py b/examples/pybind11-project/python-src/pybind11_project/__init__.py
index 0637abf..22f32d0 100644
--- a/examples/pybind11-project/python-src/pybind11_project/__init__.py
+++ b/examples/pybind11-project/python-src/pybind11_project/__init__.py
@@ -1,2 +1,3 @@
 """Example project using the py-build-cmake build backend and pybind11."""
-__version__ = '0.1.8'
\ No newline at end of file
+
+__version__ = "0.3.0"
diff --git a/examples/pybind11-project/python-src/pybind11_project/add.py b/examples/pybind11-project/python-src/pybind11_project/add.py
index c2444ef..3291e84 100644
--- a/examples/pybind11-project/python-src/pybind11_project/add.py
+++ b/examples/pybind11-project/python-src/pybind11_project/add.py
@@ -1,6 +1,8 @@
-from .add_module import add
 import sys
 
+from .add_module import add
+
+
 def main():
     """Script that adds all command line arguments as integers."""
     sum = 0
diff --git a/examples/pybind11-project/python-src/pybind11_project/add_module.py b/examples/pybind11-project/python-src/pybind11_project/add_module.py
index 2db5283..31fdfe8 100644
--- a/examples/pybind11-project/python-src/pybind11_project/add_module.py
+++ b/examples/pybind11-project/python-src/pybind11_project/add_module.py
@@ -2,9 +2,10 @@
 
 import os
 import typing
-if not typing.TYPE_CHECKING and os.getenv('PYBIND11_PROJECT_PYTHON_DEBUG'):
-    from ._add_module_d import *
-    from ._add_module_d import __version__
+
+if not typing.TYPE_CHECKING and os.getenv("PYBIND11_PROJECT_PYTHON_DEBUG"):
+    from ._add_module_d import *  # noqa: F403
+    from ._add_module_d import __version__  # noqa: F401, RUF100
 else:
-    from ._add_module import *
-    from ._add_module import __version__
+    from ._add_module import *  # noqa: F403
+    from ._add_module import __version__  # noqa: F401, RUF100
diff --git a/examples/pybind11-project/python-src/pybind11_project/sub_package/__init__.py b/examples/pybind11-project/python-src/pybind11_project/sub_package/__init__.py
index d0a82d3..bc7e6aa 100644
--- a/examples/pybind11-project/python-src/pybind11_project/sub_package/__init__.py
+++ b/examples/pybind11-project/python-src/pybind11_project/sub_package/__init__.py
@@ -1,2 +1,6 @@
-"""Example package that subtracts two integers in Python."""
-from .sub import *
\ No newline at end of file
+"""Example module that subtracts two integers in Python."""
+
+
+def sub(a: int, b: int) -> int:
+    """Subtracts two integers"""
+    return a - b
diff --git a/examples/pybind11-project/python-src/pybind11_project/sub_package/sub.py b/examples/pybind11-project/python-src/pybind11_project/sub_package/sub.py
deleted file mode 100644
index 9fe9eb9..0000000
--- a/examples/pybind11-project/python-src/pybind11_project/sub_package/sub.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""Example module that subtracts two integers in Python."""
-
-
-def sub(a: int, b: int) -> int:
-    """Subtracts two integers"""
-    return a - b
\ No newline at end of file
diff --git a/examples/pybind11-project/test/test_add_module.py b/examples/pybind11-project/tests/test_add_module.py
similarity index 81%
rename from examples/pybind11-project/test/test_add_module.py
rename to examples/pybind11-project/tests/test_add_module.py
index 7c96e7c..3802e45 100644
--- a/examples/pybind11-project/test/test_add_module.py
+++ b/examples/pybind11-project/tests/test_add_module.py
@@ -1,3 +1,6 @@
+from pybind11_project import __version__ as py_version
+from pybind11_project._add_module import __version__ as cpp_version
+from pybind11_project.add_module import __version__ as py_cpp_version
 from pybind11_project.add_module import add
 
 
@@ -5,16 +8,12 @@ def test_add():
     assert add(1, 2) == 3
 
 
-from pybind11_project import __version__ as py_version
-from pybind11_project.add_module import __version__ as py_cpp_version
-from pybind11_project._add_module import __version__ as cpp_version
-
-
 def test_version():
     assert py_version == py_cpp_version
     assert py_version == cpp_version
-    try: # No importlib in Python 3.7 and below
+    try:  # No importlib in Python 3.7 and below
         from importlib.metadata import version
-        assert py_version == version('pybind11_project')
+
+        assert py_version == version("pybind11_project")
     except ImportError:
         pass
diff --git a/examples/pybind11-project/test/test_sub_package.py b/examples/pybind11-project/tests/test_sub_package.py
similarity index 98%
rename from examples/pybind11-project/test/test_sub_package.py
rename to examples/pybind11-project/tests/test_sub_package.py
index c183043..f2408fb 100644
--- a/examples/pybind11-project/test/test_sub_package.py
+++ b/examples/pybind11-project/tests/test_sub_package.py
@@ -1,4 +1,5 @@
 from pybind11_project.sub_package import sub
 
+
 def test_sub():
     assert sub(3, 2) == 1
diff --git a/noxfile.py b/noxfile.py
index ee638eb..52fa713 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -1,89 +1,297 @@
-import shutil
-import nox
+"""
+Tests for the py-build-cmake package.
+
+ - Build all example and test projects
+   - Run the package's pytest tests
+   - Check the contents of the sdist and Wheel packages produced
+ - Build the component backend example
+   - Run the package's pytest tests
+   - Check the contents of the Wheel packages produced
+ - Test all three (+1) editable modes for the example and test projects
+   -  Install in editable mode and run the package's pytest
+ - Run the py-build-cmake pytest tests
+"""
+
+from __future__ import annotations
+
+import hashlib
 import os
+import re
+import shutil
 import sys
+from difflib import unified_diff
+from pathlib import Path
+from tarfile import open as open_tar
+from zipfile import ZipFile
+
+import jinja2
+import nox
+from distlib.util import get_platform
+
+if sys.version_info < (3, 8):
+    import distutils.sysconfig as dist_sysconfig
+else:
+    import sysconfig as dist_sysconfig
+
+version = "0.3.0"
+project_dir = Path(__file__).resolve().parent
+
+examples = "minimal-program", "pybind11-project", "nanobind-project", "minimal"
+test_packages = "namespace-project-a", "namespace-project-b"
+test_packages += "bare-c-module", "cmake-preset", "cmake-options"
+
+purity = {"namespace-project-b": True}
+
+
+def get_contents_subs(ext_suffix: str):
+    if ext_suffix.endswith(".pyd"):
+        dbg_suffix = ".pdb"
+        exe_suffix = ".exe"
+    else:
+        dbg_suffix = ext_suffix + ".debug"
+        exe_suffix = ""
+    return {
+        "version": version,
+        "ext_suffix": ext_suffix,
+        "dbg_suffix": dbg_suffix,
+        "exe_suffix": exe_suffix,
+        "sys": {
+            "version_info": sys.version_info,
+            "implementation": sys.implementation,
+            "platform": sys.platform,
+        },
+    }
+
+
+def check_pkg_contents(
+    session: nox.Session,
+    name: str,
+    ext_suffix: str,
+    with_sdist=True,
+    pure=False,
+):
+    d = project_dir / "tests" / "expected_contents" / name
+    template_env = jinja2.Environment(loader=jinja2.FileSystemLoader(d))
+    normname = re.sub(r"[-_.]+", "_", name).lower()
+    plat = "none" if pure else get_platform().replace(".", "_").replace("-", "_")
+    subs = get_contents_subs(ext_suffix)
+    # Compare sdist contents
+    sdist = Path(f"dist-nox/{normname}-{version}.tar.gz")
+    if with_sdist:
+        sdist_template = template_env.get_template("sdist.txt")
+        sdist_expect = sdist_template.render(**subs).split("\n")
+        sdist_expect = sorted(filter(bool, sdist_expect))
+        sdist_actual = sorted(open_tar(sdist).getnames())
+        if sdist_expect != sdist_actual:
+            diff = "\n".join(unified_diff(sdist_expect, sdist_actual))
+            session.error("sdist contents mismatch:\n" + diff)
+    # Find Wheel
+    whl_pattern = f"dist-nox/{normname}-{version}-*{plat}*.whl"
+    whls = list(Path().glob(whl_pattern))
+    if len(whls) != 1:
+        session.error(f"Unexpected number of Wheels {whls} ({whl_pattern})")
+    whl = whls[0]
+    # Compare Wheel contents
+    whl_template = template_env.get_template("whl.txt")
+    whl_expect = whl_template.render(**subs).split("\n")
+    whl_expect = sorted(filter(bool, whl_expect))
+    whl_actual = sorted(ZipFile(whl).namelist())
+    if whl_expect != whl_actual:
+        diff = "\n".join(unified_diff(whl_expect, whl_actual))
+        session.error("Wheel contents mismatch:\n" + diff)
+
+
+def test_example_project(
+    session: nox.Session, name: str, ext_suffix: str, dir: Path = Path("examples")
+):
+    with session.chdir(dir / name):
+        shutil.rmtree(".py-build-cmake_cache", ignore_errors=True)
+        shutil.rmtree("dist-nox", ignore_errors=True)
+        session.run("python", "-m", "build", ".", "-o", "dist-nox")
+        pure = purity.get(name, False)
+        check_pkg_contents(session, name, ext_suffix, pure=pure)
+        session.install(".")
+        session.run("pytest")
+
+
+def get_ext_suffix(name: str):
+    impl = sys.implementation
+    py_v = sys.version_info
+    ext_suffix = dist_sysconfig.get_config_var("EXT_SUFFIX")
+    assert isinstance(ext_suffix, str)
+    simple = name in ["minimal", "bare-c-module"]
+    if simple and ext_suffix.endswith(".pyd") and py_v < (3, 8):
+        ext_suffix = ".pyd"  # what a mess ...
+    if name == "nanobind-project":
+        if py_v < (3, 8):
+            ext_suffix = None  # skip
+        elif impl.name == "cpython" and py_v >= (3, 12):
+            ext_suffix = "." + ext_suffix.rsplit(".", 1)[-1]
+            if sys.platform != "win32":
+                ext_suffix = ".abi3" + ext_suffix
+    return ext_suffix
+
 
 @nox.session
 def example_projects(session: nox.Session):
     session.install("-U", "pip", "build", "pytest")
-    dist_dir = os.getenv('PY_BUILD_CMAKE_WHEEL_DIR')
+    dist_dir = os.getenv("PY_BUILD_CMAKE_WHEEL_DIR")
     if dist_dir is None:
         session.run("python", "-m", "build", ".")
         dist_dir = "dist"
-    session.env["PIP_FIND_LINKS"] = os.path.abspath(dist_dir)
-    session.install("py-build-cmake~=0.1.8")
-    with session.chdir("examples/minimal"):
-        shutil.rmtree('.py-build-cmake_cache', ignore_errors=True)
+    session.env["PIP_FIND_LINKS"] = str(Path(dist_dir).resolve())
+    session.install(f"py-build-cmake=={version}")
+    for name in examples:
+        ext_suffix = get_ext_suffix(name)
+        if ext_suffix is not None:
+            test_example_project(session, name, ext_suffix)
+
+
+@nox.session
+def test_projects(session: nox.Session):
+    dir = Path("test-packages")
+    session.install("-U", "pip", "build", "pytest")
+    dist_dir = os.getenv("PY_BUILD_CMAKE_WHEEL_DIR")
+    if dist_dir is None:
         session.run("python", "-m", "build", ".")
-        session.install(".")
-        session.run("pytest")
-    with session.chdir("examples/pybind11-project"):
-        shutil.rmtree('.py-build-cmake_cache', ignore_errors=True)
+        dist_dir = "dist"
+    session.env["PIP_FIND_LINKS"] = str(Path(dist_dir).resolve())
+    session.install(f"py-build-cmake=={version}")
+    for name in test_packages:
+        ext_suffix = get_ext_suffix(name)
+        if ext_suffix is not None:
+            test_example_project(session, name, ext_suffix, dir=dir)
+
+
+@nox.session
+def component(session: nox.Session):
+    session.install("-U", "pip", "build", "pytest")
+    dist_dir = os.getenv("PY_BUILD_CMAKE_WHEEL_DIR")
+    if dist_dir is None:
         session.run("python", "-m", "build", ".")
-        session.install(".")
-        session.run("pytest")
-    if sys.version_info >= (3, 8):
-        with session.chdir("examples/nanobind-project"):
-            shutil.rmtree('.py-build-cmake_cache', ignore_errors=True)
-            session.run("python", "-m", "build", ".")
+        dist_dir = "dist"
+    session.env["PIP_FIND_LINKS"] = str(Path(dist_dir).resolve())
+    session.install(f"py-build-cmake=={version}")
+    with session.chdir("examples/minimal-debug-component"):
+        shutil.rmtree(".py-build-cmake_cache", ignore_errors=True)
+        shutil.rmtree("dist-nox", ignore_errors=True)
+        session.run("python", "-m", "build", "-w", ".", "-o", "dist-nox")
+        session.run("python", "-m", "build", "-w", "./debug", "-o", "dist-nox")
+        ext_suffix = get_ext_suffix("minimal")
+        if ext_suffix is not None:
+            check_pkg_contents(session, "minimal-comp", ext_suffix, False)
+            check_pkg_contents(session, "minimal-comp-debug", ext_suffix, False)
             session.install(".")
+            session.install("./debug")
             session.run("pytest")
-    with session.chdir("examples/minimal-program"):
-        shutil.rmtree('.py-build-cmake_cache', ignore_errors=True)
-        session.run("python", "-m", "build", ".")
-        session.install(".")
-        session.run("pytest")
 
 
 @nox.session
-def component(session: nox.Session):
+def reproducible(session: nox.Session):
+    if os.name != "posix":
+        session.skip("Skipping reproducible builds")
     session.install("-U", "pip", "build", "pytest")
-    dist_dir = os.getenv('PY_BUILD_CMAKE_WHEEL_DIR')
+    dist_dir = os.getenv("PY_BUILD_CMAKE_WHEEL_DIR")
     if dist_dir is None:
         session.run("python", "-m", "build", ".")
         dist_dir = "dist"
-    session.env["PIP_FIND_LINKS"] = os.path.abspath(dist_dir)
-    session.install("py-build-cmake~=0.1.8")
-    with session.chdir("examples/minimal-debug-component"):
-        shutil.rmtree('.py-build-cmake_cache', ignore_errors=True)
-        session.install(".")
-        session.install("./debug")
-        session.run("pytest")
+    session.env["PIP_FIND_LINKS"] = str(Path(dist_dir).resolve())
+    session.env["SOURCE_DATE_EPOCH"] = "1732565790"
 
+    def build_and_hash(name):
+        shutil.rmtree(".py-build-cmake_cache", ignore_errors=True)
+        shutil.rmtree("dist-nox", ignore_errors=True)
+        override = "override.cmake.options.REPRODUCIBLE_PROJECT_DIR=true"
+        session.run("python", "-m", "build", "-o", "dist-nox", "-C", override)
+        normname = re.sub(r"[-_.]+", "_", name).lower()
+        plat = get_platform().replace(".", "_").replace("-", "_")
+        sdist = Path(f"dist-nox/{normname}-{version}.tar.gz")
+        whl_pattern = f"dist-nox/{normname}-{version}-*{plat}*.whl"
+        whls = list(Path().glob(whl_pattern))
+        if len(whls) != 1:
+            session.error(f"Unexpected number of Wheels {whls} ({whl_pattern})")
+        whl = whls[0]
+        sdist_hash = hashlib.sha256(sdist.read_bytes()).hexdigest()
+        whl_hash = hashlib.sha256(whl.read_bytes()).hexdigest()
+        return sdist_hash, whl_hash
 
-def test_editable(session: nox.Session, mode: str):
-    tmpdir = os.path.realpath(session.create_tmp())
+    test_proj = Path("test-packages/namespace-project-a")
+    with session.chdir(test_proj):
+        hashes = build_and_hash(test_proj.name)
+    tmpdir = Path(session.create_tmp()).resolve()
     try:
-        with session.chdir("examples/pybind11-project"):
-            shutil.rmtree('.py-build-cmake_cache', ignore_errors=True)
-            with open(os.path.join(tmpdir, f"{mode}.toml"), "w") as f:
-                f.write(f"[editable]\nmode = \"{mode}\"")
-            session.install("-e", ".", "--config-settings=--local=" + f.name)
+        shutil.copytree(test_proj, tmpdir / test_proj.name)
+        with session.chdir(tmpdir / test_proj.name):
+            tmp_hashes = build_and_hash(test_proj.name)
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+    print(hashes)
+    print(tmp_hashes)
+    assert hashes == tmp_hashes
+
+
+def test_editable(
+    session: nox.Session, name: str, mode: str, dir: Path = Path("examples")
+):
+    ext_suffix = get_ext_suffix(name)
+    if ext_suffix is None:
+        return
+    tmpdir = Path(session.create_tmp()).resolve()
+    m = mode.split("+", 1)
+    bh = len(m) > 1 and m[1] == "build_hook"
+    skip_wrapper = ("namespace", "bare", "cmake-preset", "cmake-options")
+    if m[0] == "wrapper" and any(k in name for k in skip_wrapper):
+        return
+    if m[0] == "symlink" and name == "minimal-program":
+        return
+    try:
+        with session.chdir(dir / name):
+            shutil.rmtree(".py-build-cmake_cache", ignore_errors=True)
+            with (tmpdir / f"{mode}.toml").open("w") as f:
+                f.write(f'[editable]\nmode = "{m[0]}"\n')
+                f.write(f"build_hook = {str(bh).lower()}")
+            args = ("--config-settings=--local=" + f.name,)
+            if bh:
+                args += ("--no-build-isolation",)
+            session.install("-e", ".", *args)
             session.run("pytest")
     finally:
         shutil.rmtree(tmpdir, ignore_errors=True)
 
 
 @nox.session
-def editable(session: nox.Session):
-    session.install("-U", "pip", "build", "pytest")
-    dist_dir = os.getenv('PY_BUILD_CMAKE_WHEEL_DIR')
+@nox.parametrize("mode", ["symlink", "symlink+build_hook", "hook", "wrapper"])
+def editable(session: nox.Session, mode):
+    session.install(
+        "-U",
+        "pip",
+        "build",
+        "pytest",
+        "pybind11~=2.13.5",
+        "pybind11-stubgen~=2.5.1",
+        "nanobind~=2.2.0",
+        "cmake",
+        "ninja",
+    )
+    dist_dir = os.getenv("PY_BUILD_CMAKE_WHEEL_DIR")
     if dist_dir is None:
         session.run("python", "-m", "build", ".")
         dist_dir = "dist"
-    session.env["PIP_FIND_LINKS"] = os.path.abspath(dist_dir)
-    session.install("py-build-cmake~=0.1.8")
-    for mode in ("wrapper", "hook", "symlink"):
-        test_editable(session, mode)
+    session.env["PIP_FIND_LINKS"] = str(Path(dist_dir).resolve())
+    session.install(f"py-build-cmake=={version}")
+    for name in examples:
+        test_editable(session, name, mode)
+    for name in test_packages:
+        test_editable(session, name, mode, dir=Path("test-packages"))
 
 
 @nox.session
 def tests(session: nox.Session):
     session.install("-U", "pip", "pytest")
-    dist_dir = os.getenv('PY_BUILD_CMAKE_WHEEL_DIR')
+    dist_dir = os.getenv("PY_BUILD_CMAKE_WHEEL_DIR")
     if dist_dir:
-        session.env["PIP_FIND_LINKS"] = os.path.abspath(dist_dir)
-        session.install("py-build-cmake~=0.1.8")
+        session.env["PIP_FIND_LINKS"] = str(Path(dist_dir).resolve())
+        session.install(f"py-build-cmake=={version}")
     else:
         session.install(".")
-    session.run('pytest')
+    session.run("pytest")
diff --git a/pyproject.toml b/pyproject.toml
index 9b25008..d05909f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,5 +1,11 @@
 [build-system]
-requires = ["distlib", "flit_core>=3.7,<4", "tomli>=1.2.3,<3; python_version < '3.11'"]
+requires = [
+    "distlib~=0.3.5",
+    "packaging>=23.2",
+    "pyproject-metadata~=0.7.1",
+    "tomli>=1.2.3,<3; python_version < '3.11'",
+    "lark>=1.1.9,<2",
+]
 build-backend = "py_build_cmake.build"
 backend-path = ["src"]
 
@@ -19,14 +25,18 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: MacOS",
 ]
 dependencies = [
     "distlib~=0.3.5",
-    "flit_core>=3.7,<4",
+    "packaging>=23.2",
+    "pyproject-metadata~=0.7.1",
     "tomli>=1.2.3,<3; python_version < '3.11'",
+    "lark>=1.1.9,<2",
     "click~=8.1.3",
 ]
 dynamic = ["version", "description"]
@@ -39,8 +49,88 @@ Tracker = "https://github.com/tttapa/py-build-cmake/issues"
 [project.scripts]
 py-build-cmake = "py_build_cmake.cli:cli"
 
+[project.optional-dependencies]
+test = ["nox>=2023.4.22,<2024", "jinja2~=3.1.2"]
+
 [tool.py-build-cmake.module]
 name = "py_build_cmake"
 
 [tool.pytest.ini_options]
-testpaths = ["test"]
+minversion = "6.0"
+addopts = ["-ra", "--showlocals", "--strict-markers", "--strict-config"]
+xfail_strict = true
+filterwarnings = ["error"]
+log_cli_level = "info"
+testpaths = ["tests"]
+norecursedirs = ["tests/packages"]
+
+[tool.ruff]
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "W",   # flake8
+    "B",   # flake8-bugbear
+    "I",   # isort
+    "C4",  # flake8-comprehensions
+    "EM",  # flake8-errmsg
+    "ICN", # flake8-import-conventions
+    "G",   # flake8-logging-format
+    "PGH", # pygrep-hooks
+    "PIE", # flake8-pie
+    "PL",  # pylint
+    "PT",  # flake8-pytest-style
+    "PTH", # flake8-use-pathlib
+    "RET", # flake8-return
+    "RUF", # Ruff-specific
+    "SIM", # flake8-simplify
+    "T20", # flake8-print
+    "UP",  # pyupgrade
+    "YTT", # flake8-2020
+    "EXE", # flake8-executable
+]
+extend-ignore = [
+    "E501",    # Line too long
+    "E731",    # Lambda assignment
+    "PLR2004", # Magic values
+    "PLR0913", # Too many function arguments
+    "RET505",  # Unnecessary `elif` after `return`
+    "RET506",  # Unnecessary `elif` after `raise`
+    "PGH003",  # Specific rules `type: ignore`
+]
+
+[tool.ruff.lint.per-file-ignores]
+"noxfile.py" = ["T20"]                                # Removes print statements
+"**/tests/**" = ["T20"]
+"examples/**" = ["T20"]
+"scripts/**" = ["T20"]
+"src/py_build_cmake/build.py" = ["T20"]
+"src/py_build_cmake/commands/cmake.py" = ["T20"]
+"src/py_build_cmake/commands/cmd_runner.py" = ["T20"]
+"src/py_build_cmake/config/load.py" = ["T20"]
+"src/py_build_cmake/help.py" = ["T20"]
+
+[tool.mypy]
+python_version = "3.8"
+files = "src/**/*.py"
+packages = "src/py_build_cmake"
+show_error_codes = true
+enable_error_code = [
+    "type-arg",
+    "redundant-cast",
+    "redundant-self",
+    "comparison-overlap",
+    "no-any-return",
+    "no-any-unimported",
+    "unreachable",
+    "redundant-expr",
+    "possibly-undefined",
+    "truthy-bool",
+    "truthy-iterable",
+    "ignore-without-code",
+    "unused-awaitable",
+    "unused-ignore",
+]
+warn_unreachable = true
+strict_optional = true
+implicit_reexport = true
diff --git a/scripts/ci/install-patchelf.sh b/scripts/ci/install-patchelf.sh
index 99c4f2f..78f7cdd 100755
--- a/scripts/ci/install-patchelf.sh
+++ b/scripts/ci/install-patchelf.sh
@@ -17,4 +17,4 @@ make -j$(nproc)
 make check
 make install
 popd
-popd
\ No newline at end of file
+popd
diff --git a/scripts/download-cross-toolchains-linux.sh b/scripts/download-cross-toolchains-linux.sh
new file mode 100755
index 0000000..58727e6
--- /dev/null
+++ b/scripts/download-cross-toolchains-linux.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+# This script downloads cross-compilation toolchains for a range of popular
+# architectures (x86-64, ARMv6, ARMv7, ARMv8-64), as well as binaries of all
+# current versions of CPython and PyPy.
+# These can then be used to cross-compile packages using py-build-cmake
+
+cd "$( dirname "${BASH_SOURCE[0]}" )"/..
+
+triples=(x86_64-bionic-linux-gnu armv6-rpi-linux-gnueabihf armv7-neon-linux-gnueabihf aarch64-rpi3-linux-gnu)
+gcc_version="14"
+toolchain_version="1.0.0"
+python_dev_version="0.0.6"
+toolchain_folder="$PWD/toolchains"
+
+set -ex
+
+mkdir -p "$toolchain_folder/x-tools"
+for triple in ${triples[@]}; do
+    chmod u+w "$toolchain_folder/x-tools"
+    if [ ! -d "$toolchain_folder/x-tools/$triple" ]; then
+        url=https://github.com/tttapa/toolchains/releases/download/$toolchain_version
+        wget "$url/x-tools-$triple-gcc$gcc_version.tar.xz" -O- | tar xJ -C "$toolchain_folder"
+    fi
+    chmod u+w "$toolchain_folder/x-tools/$triple"
+    if [ ! -d "$toolchain_folder/x-tools/$triple/python" ]; then
+        url=https://github.com/tttapa/python-dev/releases/download
+        wget "$url/$python_dev_version/python-dev-$triple.tar.xz" -O- | tar xJ -C "$toolchain_folder"
+    fi
+done
+
+# To delete the toolchains again, use
+#   chmod -R u+w toolchains && rm -rf toolchains
diff --git a/scripts/list_contents.py b/scripts/list_contents.py
new file mode 100644
index 0000000..21b6777
--- /dev/null
+++ b/scripts/list_contents.py
@@ -0,0 +1,23 @@
+from tarfile import open as tar_open
+from zipfile import ZipFile
+
+tar_files = [
+    "examples/minimal-program/dist-nox/minimal_program-0.2.0a5.tar.gz",
+    "examples/minimal/dist-nox/minimal-0.2.0a5.tar.gz",
+    "examples/pybind11-project/dist-nox/pybind11_project-0.2.0a5.tar.gz",
+    "examples/nanobind-project/dist-nox/nanobind_project-0.2.0a5.tar.gz",
+]
+
+zip_files = [
+    "examples/minimal-program/dist-nox/minimal_program-0.2.0a5-py3-none-linux_x86_64.whl",
+    "examples/minimal/dist-nox/minimal-0.2.0a5-cp39-cp39-linux_x86_64.whl",
+    "examples/pybind11-project/dist-nox/pybind11_project-0.2.0a5-cp39-cp39-linux_x86_64.whl",
+    "examples/nanobind-project/dist-nox/nanobind_project-0.2.0a5-cp39-cp39-linux_x86_64.whl",
+    "examples/minimal-debug-component/dist-nox/minimal_comp-0.2.0a5-cp39-cp39-linux_x86_64.whl",
+    "examples/minimal-debug-component/dist-nox/minimal_comp_debug-0.2.0a5-cp39-cp39-linux_x86_64.whl",
+]
+
+for f in tar_files:
+    print(*sorted(tar_open(f).getnames()), sep="\n", end="\n\n")
+for f in zip_files:
+    print(*sorted(ZipFile(f).namelist()), sep="\n", end="\n\n")
diff --git a/src/py_build_cmake/__init__.py b/src/py_build_cmake/__init__.py
index d678407..a3d4351 100644
--- a/src/py_build_cmake/__init__.py
+++ b/src/py_build_cmake/__init__.py
@@ -2,4 +2,5 @@
 Modern, PEP 517 compliant build backend for creating Python packages with
 extensions built using CMake.
 """
-__version__ = '0.1.8'
\ No newline at end of file
+
+__version__ = "0.3.0"
diff --git a/src/py_build_cmake/build.py b/src/py_build_cmake/build.py
index 9362922..cb5dc46 100644
--- a/src/py_build_cmake/build.py
+++ b/src/py_build_cmake/build.py
@@ -1,28 +1,51 @@
-import platform
-from pprint import pprint
+from __future__ import annotations
+
+import contextlib
+import logging
 import os
-from pathlib import Path
-from copy import copy
+import platform
 import shutil
-import textwrap
-from typing import Any, Dict, List, Optional
 import tempfile
-from glob import glob
-
-from . import config
-from . import cmake
-from .datastructures import BuildPaths, PackageInfo
-from .cmd_runner import CommandRunner
-
-import flit_core.common  # type: ignore
-import flit_core.config  # type: ignore
-from distlib.version import NormalizedVersion  # type: ignore
-
-_CMAKE_MINIMUM_REQUIRED = NormalizedVersion('3.15')
-
-
-class _BuildBackend(object):
-
+from pathlib import Path
+from typing import Any
+
+from .commands.cmake import (
+    CMakeBuildSettings,
+    CMakeConfigureSettings,
+    CMakeInstallSettings,
+    CMaker,
+    CMakeSettings,
+)
+from .commands.cmd_runner import CommandRunner
+from .commands.try_run import check_cmake_program, check_stubgen_program
+from .common import (
+    BuildPaths,
+    ComponentConfig,
+    Config,
+    ConfigError,
+    FormattedErrorMessage,
+    Module,
+    PackageInfo,
+    ProblemInModule,
+    format_and_rethrow_exception,
+    logformat,
+    util,
+)
+from .config import load as config_load
+from .config.dynamic import find_module, update_dynamic_metadata
+from .export import editable as export_editable
+from .export import metadata as export_metadata
+from .export import util as export_util
+from .export.editable.build_hook import write_build_hook
+from .export.native_tags import get_interpreter_name
+from .export.sdist import SdistBuilder
+from .export.tags import convert_wheel_tags, get_cross_tags, get_native_tags, is_pure
+from .export.wheel import WheelBuilder
+
+logger = logging.getLogger(__name__)
+
+
+class _BuildBackend:
     # --- Constructor ---------------------------------------------------------
 
     def __init__(self) -> None:
@@ -36,13 +59,14 @@ def verbose(self):
 
     def get_requires_for_build_wheel(self, config_settings=None):
         """https://www.python.org/dev/peps/pep-0517/#get-requires-for-build-wheel"""
-        self.parse_config_settings(config_settings)
+        try:
+            self.parse_config_settings(config_settings)
 
-        pyproject = Path('pyproject.toml').resolve()
-        cfg = _BuildBackend.read_config(pyproject, config_settings,
-                                        self.verbose)
-        return self.get_requires_build_project(config_settings, cfg,
-                                               self.runner)
+            src_dir = Path().resolve()
+            cfg = self.read_config(src_dir, config_settings, self.verbose)
+            return self.get_requires_build_project(config_settings, cfg, self.runner)
+        except Exception as e:
+            format_and_rethrow_exception(e)
 
     def get_requires_for_build_editable(self, config_settings=None):
         """https://www.python.org/dev/peps/pep-0660/#get-requires-for-build-editable"""
@@ -52,517 +76,427 @@ def get_requires_for_build_sdist(self, config_settings=None):
         """https://www.python.org/dev/peps/pep-0517/#get-requires-for-build-sdist"""
         return []
 
-    def build_wheel(self,
-                    wheel_directory,
-                    config_settings=None,
-                    metadata_directory=None):
+    def build_wheel(
+        self, wheel_directory, config_settings=None, metadata_directory=None
+    ):
         """https://www.python.org/dev/peps/pep-0517/#build-wheel"""
-        assert metadata_directory is None
-
-        # Parse options
-        self.parse_config_settings(config_settings)
-
-        # Build wheel
-        with tempfile.TemporaryDirectory() as tmp_build_dir:
-            whl_name = self.build_wheel_in_dir(wheel_directory, tmp_build_dir,
-                                               config_settings)
-        return whl_name
-
-    def build_editable(self,
-                       wheel_directory,
-                       config_settings=None,
-                       metadata_directory=None):
+        try:
+            assert metadata_directory is None
+
+            # Parse options
+            self.parse_config_settings(config_settings)
+
+            # Build wheel
+            with tempfile.TemporaryDirectory() as tmp_build_dir:
+                return self.build_wheel_in_dir(
+                    wheel_directory, tmp_build_dir, config_settings
+                )
+        except Exception as e:
+            format_and_rethrow_exception(e)
+
+    def build_editable(
+        self, wheel_directory, config_settings=None, metadata_directory=None
+    ):
         """https://www.python.org/dev/peps/pep-0660/#build-editable"""
-        assert metadata_directory is None
+        try:
+            assert metadata_directory is None
 
-        # Parse options
-        self.parse_config_settings(config_settings)
+            # Parse options
+            self.parse_config_settings(config_settings)
 
-        # Build wheel
-        with tempfile.TemporaryDirectory() as tmp_build_dir:
-            whl_name = self.build_wheel_in_dir(wheel_directory,
-                                               tmp_build_dir,
-                                               config_settings,
-                                               editable=True)
-        return whl_name
+            # Build wheel
+            with tempfile.TemporaryDirectory() as tmp_build_dir:
+                return self.build_wheel_in_dir(
+                    wheel_directory, tmp_build_dir, config_settings, editable=True
+                )
+        except Exception as e:
+            format_and_rethrow_exception(e)
 
     def build_sdist(self, sdist_directory, config_settings=None):
         """https://www.python.org/dev/peps/pep-0517/#build-sdist"""
-        sdist_directory = Path(sdist_directory)
-        src_dir = Path().resolve()
-
-        # Parse options
-        self.parse_config_settings(config_settings)
+        try:
+            # Parse options
+            self.parse_config_settings(config_settings)
 
-        # Load metadata
-        from flit_core.common import Module, make_metadata
-        pyproject = src_dir / 'pyproject.toml'
-        cfg = self.read_config(pyproject, config_settings, self.verbose)
-        import_name = cfg.module['name']
-        pkg = Module(import_name, src_dir / cfg.module['directory'])
-        metadata = make_metadata(pkg, cfg)
-        metadata.version = self.normalize_version(metadata.version)
-
-        # Export dist
-        from flit_core.sdist import SdistBuilder  # type: ignore
-        rel_pyproject = os.path.relpath(pyproject, src_dir)
-        extra_files = [str(rel_pyproject)] + cfg.referenced_files
-        sdist_cfg = cfg.sdist[self.get_os_name()]
-        sdist_builder = SdistBuilder(
-            pkg,
-            metadata=metadata,
-            cfgdir=src_dir,
-            reqs_by_extra=None,
-            entrypoints=cfg.entrypoints,
-            extra_files=extra_files,
-            data_directory=None,
-            include_patterns=sdist_cfg.get('include_patterns', []),
-            exclude_patterns=sdist_cfg.get('exclude_patterns', []),
-        )
-        sdist_tar = sdist_builder.build(Path(sdist_directory))
-        return os.path.relpath(sdist_tar, sdist_directory)
+            return self.do_build_sdist(sdist_directory, config_settings)
+        except Exception as e:
+            format_and_rethrow_exception(e)
 
     # --- Parsing config options and metadata ---------------------------------
 
     @staticmethod
-    def is_verbose_enabled(config_settings: Optional[dict]):
-        if 'PY_BUILD_CMAKE_VERBOSE' in os.environ:
-            return True
-        if config_settings is None:
-            return False
-        if config_settings.keys() & {'verbose', '--verbose', 'V', '-V'}:
-            return True
+    def is_verbose_enabled(config_settings: dict | None):
+        truthy = lambda x: x.lower() in ("", "1", "true", "yes", "y")
+        if config_settings is not None:
+            verbose_keys = {"verbose", "--verbose", "V", "-V"}
+            verbose_opts = {
+                k: v for k, v in config_settings.items() if k in verbose_keys
+            }
+            if verbose_opts:
+                last_val = next(reversed(list(verbose_opts.values())))
+                return truthy(last_val)
+        env_verbose = os.environ.get("PY_BUILD_CMAKE_VERBOSE")
+        if env_verbose is not None:
+            return truthy(env_verbose)
         return False
 
-    def parse_config_settings(self, config_settings: Optional[Dict]):
-        self.runner.verbose = self.is_verbose_enabled(config_settings)
-
     @staticmethod
-    def read_config(pyproject_path: Path, config_settings: Optional[Dict],
-                    verbose: bool) -> config.Config:
-        config_settings = config_settings or {}
+    def get_log_level(config_settings: dict | None) -> int:
+        def parse_log_level(loglevel: str) -> int:
+            numeric_level = getattr(logging, loglevel.upper(), None)
+            if isinstance(numeric_level, int):
+                return numeric_level
+            raise ValueError("Invalid log level: %s" % loglevel)
+
+        if config_settings is not None:
+            log_keys = {"loglevel", "--loglevel"}
+            log_opts = {k: v for k, v in config_settings.items() if k in log_keys}
+            if log_opts:
+                last_val = next(reversed(list(log_opts.values())))
+                return parse_log_level(last_val)
+        env_log = os.environ.get("PY_BUILD_CMAKE_LOGLEVEL")
+        if env_log is not None:
+            return parse_log_level(env_log)
+        return logging.INFO
+
+    def parse_config_settings(self, config_settings: dict | None):
         try:
-            if verbose:
-                print("Configuration settings:")
-                pprint(config_settings)
-            listify = lambda x: x if isinstance(x, list) else [x]
-            keys = ['--local', '--cross']
-            overrides = {
-                key: listify(config_settings.get(key) or [])
-                for key in keys
-            }
-            if verbose:
-                print("Configuration settings for local and "
-                      "cross-compilation overrides:")
-                pprint(overrides)
-            cfg = config.read_config(pyproject_path, overrides)
-        except flit_core.config.ConfigError as e:
-            e.args = ("\n"
-                      "\n"
-                      "\t❌ Error in user configuration:\n"
-                      "\n"
-                      f"\t\t{e}\n"
-                      "\n", )
-            raise
-        except AssertionError as e:
-            e.args = (
-                "\n"
-                "\n"
-                "\t❌ Internal error while processing the configuration\n"
-                "\t   Please notify the developers: https://github.com/tttapa/py-build-cmake/issues\n"
-                "\n"
-                f"\t\t{e}\n"
-                "\n", )
-            raise
-        if verbose:
-            _BuildBackend.print_config_verbose(cfg)
-        return cfg
+            level = self.get_log_level(config_settings)
+            if "GITHUB_ACTIONS" in os.environ:
+                formatter = logformat.GitHubActionsFormatter()
+                handler = logging.StreamHandler()
+                handler.setFormatter(formatter)
+                logging.basicConfig(level=level, handlers=[handler])
+            else:
+                logging.basicConfig(level=level)
+        except ValueError as e:
+            logger.error("Invalid log level specified", exc_info=e)
+        self.runner.verbose = self.is_verbose_enabled(config_settings)
 
     @staticmethod
-    def get_requires_build_project(config_settings: Optional[dict],
-                                   cfg: config.Config, runner: CommandRunner):
-        deps: List[str] = []
+    def get_requires_build_project(
+        config_settings: dict | None, cfg: Config, runner: CommandRunner
+    ):
+        deps: list[str] = []
         # Check if we need CMake
         if cfg.cmake:
-            _BuildBackend.check_cmake_program(cfg, deps, runner)
+            check_cmake_program(cfg, deps, runner)
         if cfg.stubgen:
-            _BuildBackend.check_stubgen_program(deps, runner)
+            check_stubgen_program(deps, runner)
         if runner.verbose:
-            print('Dependencies for build:', deps)
+            print("Dependencies for build:", deps)
         return deps
 
     # --- Building wheels -----------------------------------------------------
 
-    def build_wheel_in_dir(self,
-                           wheel_directory_,
-                           tmp_build_dir,
-                           config_settings,
-                           editable=False):
+    def build_wheel_in_dir(
+        self, wheel_dir, tmp_build_dir, config_settings, editable=False
+    ):
         """This is the main function that contains all steps necessary to build
         a complete wheel package, including the CMake builds etc."""
-        # Set up all paths
-        paths = BuildPaths(
-            source_dir=Path().resolve(),
-            wheel_dir=Path(wheel_directory_),
-            temp_dir=Path(tmp_build_dir),
-            staging_dir=Path(tmp_build_dir) / 'staging',
-            pkg_staging_dir=Path(tmp_build_dir) / 'staging',
-        )
 
         # Load metadata from the pyproject.toml file
-        cfg, pkg, metadata = _BuildBackend.read_all_metadata(
-            paths.source_dir, config_settings, self.verbose)
+        src_dir = Path().resolve()
+        cfg, module = self.read_all_metadata(src_dir, config_settings, self.verbose)
+        pkg_info = self.get_pkg_info(cfg, module)
+        cmake_cfg = self.get_cmake_config(cfg)
 
-        pkg_info = PackageInfo(
-            version=metadata.version,
-            package_name=cfg.package_name,
-            module_name=cfg.module['name'],
-        )
+        # Set up all paths
+        paths = self.get_default_paths(wheel_dir, tmp_build_dir, src_dir, cfg)
 
         # Copy the module's Python source files to the temporary folder
         if not editable:
-            self.copy_pkg_source_to(paths.staging_dir, pkg)
+            export_util.copy_pkg_source_to(paths.staging_dir, module)
         else:
-            paths = self.do_editable_install(cfg, paths, pkg)
+            paths = export_editable.do_editable_install(cfg, paths, module)
 
         # Create dist-info folder
-        distinfo_dir = f'{pkg_info.package_name}-{pkg_info.version}.dist-info'
+        distinfo_dir = f"{pkg_info.norm_name}-{pkg_info.version}.dist-info"
         distinfo_dir = paths.pkg_staging_dir / distinfo_dir
-        os.makedirs(distinfo_dir, exist_ok=True)
+        distinfo_dir.mkdir(parents=True, exist_ok=True)
 
-        # Write metadata
-        metadata_path = distinfo_dir / 'METADATA'
-        with open(metadata_path, 'w', encoding='utf-8') as f:
-            metadata.write_metadata_file(f)
-        # Write or copy license
-        self.write_license_files(cfg.license, paths.source_dir, distinfo_dir)
-        # Write entrypoints/scripts
-        self.write_entrypoints(distinfo_dir, cfg.entrypoints)
+        # Write metadata, license and entry points to Wheel's distinfo
+        export_metadata.write_metadata(cfg, distinfo_dir)
+        export_metadata.write_license_files(cfg, distinfo_dir)
+        export_metadata.write_entry_points(cfg, distinfo_dir)
+
+        # Configure, build and install the CMake project
+        for idx, cmkcfg in cmake_cfg.items():
+            build_cfg_name = _BuildBackend.get_build_config_name(cfg.cross, idx)
+            path = cmkcfg["build_path"]
+            path = str(path).replace("{build_config}", build_cfg_name)
+            build_dir = Path(path)
+            cmaker = self.get_cmaker(
+                paths.source_dir,
+                build_dir,
+                paths.staging_dir,
+                cmkcfg,
+                cfg.cross,
+                pkg_info,
+                runner=self.runner,
+            )
+            cmaker.configure()
+            cmaker.build()
+            cmaker.install()
+
+            if editable:
+                write_build_hook(cfg, paths.pkg_staging_dir, module, cmaker, idx)
 
         # Generate .pyi stubs (for the Python files only)
         if cfg.stubgen is not None and not editable:
-            self.generate_stubs(paths, pkg, cfg.stubgen)
-
-        # Configure, build and install the CMake project
-        if cfg.cmake:
-            self.do_native_cross_cmake_build(paths, cfg, pkg_info)
+            self.generate_stubs(paths, module, cfg.stubgen)
 
         # Create wheel
-        whl_name = self.create_wheel(paths, cfg, pkg_info)
-        return whl_name
+        return self.create_wheel(paths, cfg, cmake_cfg, pkg_info)
 
     @staticmethod
-    def read_all_metadata(src_dir, config_settings, verbose):
-        from flit_core.common import Module, make_metadata, ProblemInModule
-        cfg = _BuildBackend.read_config(src_dir / 'pyproject.toml',
-                                        config_settings, verbose)
-        pkg = Module(cfg.module['name'], src_dir / cfg.module['directory'])
+    def get_pkg_info(cfg: Config | ComponentConfig, module: Module | None):
+        return PackageInfo(
+            version=str(cfg.standard_metadata.version),
+            package_name=cfg.package_name,
+            module_name=module.name if module is not None else "",
+        )
+
+    @staticmethod
+    def get_default_paths(wheel_dir, tmp_build_dir, src_dir, cfg):
+        build_cfg_name = _BuildBackend.get_build_config_name(cfg.cross, 0)
+        build_dir = src_dir / ".py-build-cmake_cache" / build_cfg_name
+        return BuildPaths(
+            source_dir=src_dir,
+            build_dir=build_dir,
+            wheel_dir=Path(wheel_dir),
+            temp_dir=Path(tmp_build_dir),
+            staging_dir=Path(tmp_build_dir) / "staging",
+            pkg_staging_dir=Path(tmp_build_dir) / "staging",
+        )
+
+    @staticmethod
+    def read_all_metadata(src_dir, config_settings, verbose) -> tuple[Config, Module]:
+        cfg = _BuildBackend.read_config(src_dir, config_settings, verbose)
+        module = find_module(cfg.module, src_dir)
+        modfile = module.full_file
+        if cfg.standard_metadata.dynamic:
+            if module.is_generated:
+                msg = "Dynamic metadata is not supported for generated modules/packages"
+                raise ConfigError(msg)
+            elif module.is_namespace:
+                msg = "Dynamic metadata is not supported for namespace packages"
+                raise ConfigError(msg)
         try:
-            metadata = make_metadata(pkg, cfg)
+            update_dynamic_metadata(cfg.standard_metadata, modfile)
         except ImportError as e:
-            if hasattr(e, "msg"):
-                e.msg = (
-                    "\n"
-                    "\n"
-                    f"\t❌ Error importing {pkg.name} for reading metadata:\n"
-                    "\n"
-                    f"\t\t{e.msg}\n"
-                    "\n")
-            raise
+            logger.error("Error importing %s for reading metadata", str(modfile))
+            msg = (
+                "\n"
+                "\n"
+                f"\t\u274C Error importing {modfile} for reading metadata:\n"
+                "\n"
+                f"\t\t{e.msg}\n"
+                "\n"
+            )
+            raise FormattedErrorMessage(msg) from e
         except ProblemInModule as e:
-            e.args = ("\n"
-                      "\n"
-                      f"\t❌ Error reading metadata from {pkg.name}:"
-                      "\n"
-                      "\n"
-                      f"\t\t{e}\n"
-                      "\n", )
-            raise
-        metadata.version = _BuildBackend.normalize_version(metadata.version)
-        metadata.name = cfg.package_name
-        return cfg, pkg, metadata
+            logger.error("Error reading metadata from %s", str(modfile))
+            msg = (
+                "\n"
+                "\n"
+                f"\t\u274C Error reading metadata from {modfile}:"
+                "\n"
+                "\n"
+                f"\t\t{e}\n"
+                "\n"
+            )
+            raise FormattedErrorMessage(msg) from e
+        return cfg, module
 
     @staticmethod
-    def create_wheel(paths, cfg, package_info):
+    def read_config(src_dir, config_settings, verbose):
+        """Read the configuration without the dynamic data."""
+        return config_load.read_full_config(
+            src_dir / "pyproject.toml", config_settings, verbose
+        )
+
+    @staticmethod
+    def create_wheel(
+        paths: BuildPaths, cfg: Config, cmake_cfg, package_info: PackageInfo
+    ):
         """Create a wheel package from the build directory."""
-        from distlib.wheel import Wheel  # type: ignore
-        whl = Wheel()
-        whl.name = package_info.package_name
+        whl = WheelBuilder()
+        whl.name = package_info.norm_name
         whl.version = package_info.version
-        pure = not cfg.cmake
-        libdir = 'purelib' if pure else 'platlib'
+        wheel_cfg = _BuildBackend.get_wheel_config(cfg)
+        pure = is_pure(wheel_cfg, cmake_cfg)
+        libdir = "purelib" if pure else "platlib"
         staging_dir = paths.pkg_staging_dir
-        whl_paths = {'prefix': str(staging_dir), libdir: str(staging_dir)}
+        whl_paths = {"prefix": str(staging_dir), libdir: str(staging_dir)}
         whl.dirname = paths.wheel_dir
+        if wheel_cfg.get("build_tag"):
+            whl.buildver = wheel_cfg["build_tag"]
+        plat = wheel_cfg.get("platform_tag", "")
+        guess_plat = "guess" in plat
         if pure:
-            tags = {'pyver': ['py3']}
+            tags = {"pyver": ["py3"]}
         elif cfg.cross:
-            tags = _BuildBackend.get_cross_tags(cfg.cross)
+            if guess_plat:
+                msg = "Option `wheel.platform_tag=guess` is not supported when "
+                msg += "cross-compiling. Ignoring."
+                logger.warning(msg)
+            tags = get_cross_tags(cfg.cross)
+            tags = convert_wheel_tags(tags, wheel_cfg)
         else:
-            tags = _BuildBackend.get_native_tags()
+            tags = get_native_tags(guess_plat)
+            tags = convert_wheel_tags(tags, wheel_cfg)
         wheel_path = whl.build(whl_paths, tags=tags, wheel_version=(1, 0))
-        whl_name = os.path.relpath(wheel_path, paths.wheel_dir)
-        return whl_name
+        logger.debug("Built Wheel: %s", wheel_path)
+        return str(Path(wheel_path).relative_to(paths.wheel_dir))
 
     @staticmethod
-    def get_cmake_configs(cfg):
-        native_cmake_cfg = cfg.cmake[_BuildBackend.get_os_name()]
-        cmake_cfg = cfg.cmake['cross'] if cfg.cross else native_cmake_cfg
-        return cmake_cfg, native_cmake_cfg
-
-    def do_native_cross_cmake_build(self, paths: BuildPaths, cfg,
-                                    package_info):
-        """If not cross-compiling, just do a regular CMake build+install.
-        When cross-compiling, do a cross-build+install (using the provided 
-        CMake toolchain file).
-        If cfg.cross['copy_from_native_build'] is set, before cross-compiling, 
-        first a normal build+install is performed to a separate directory, then
-        the cross-build+install is performed, and finally the installed files
-        from the native build that match the patterns in
-        cfg.cross['copy_from_native_build'] are copied to the installation
-        directory of the cross-build for packaging."""
-        cmake_cfg, native_cmake_cfg = self.get_cmake_configs(cfg)
-        # When cross-compiling, optionally do a native build first
-        native_install_dir = None
-        if self.needs_cross_native_build(cfg):
-            native_install_dir = paths.temp_dir / 'native-install'
-            self.run_cmake(paths.source_dir, native_install_dir,
-                           native_cmake_cfg, None, package_info,
-                           native_install_dir)
-        # Then do the actual build
-        self.run_cmake(paths.source_dir, paths.staging_dir, cmake_cfg,
-                       cfg.cross, package_info, native_install_dir)
-        # Finally, move the files from the native build to the staging area
-        if native_install_dir:
-            self.copy_native_install(paths.staging_dir,
-                                     native_install_dir,
-                                     cfg.cross['copy_from_native_build'])
-
-    def copy_native_install(self, staging_dir, native_install_dir,
-                            native_install_patterns):
-        """Copy the files that match the patterns from the native installation
-        directory to the wheel staging directory."""
-        for pattern in native_install_patterns:
-            matches = sorted(glob(str(native_install_dir / pattern)))
-            for path in matches:
-                path = Path(path)
-                rel = path.relative_to(native_install_dir)
-                path.parent.mkdir(parents=True, exist_ok=True)
-                print('-- Moving:', path, '->', staging_dir / rel.parent)
-                shutil.move(path, staging_dir / rel.parent)
-                # TODO: what if the folder already exists?
-            if not matches:
-                raise RuntimeError(
-                    "Native build installed no files that matched the "
-                    "pattern '" + pattern + "'")
-        shutil.rmtree(native_install_dir)
-
-    # --- Files installation --------------------------------------------------
+    def get_cmake_config(cfg: Config) -> dict[int, Any]:
+        if not cfg.cmake:
+            return {}
+        if cfg.cross is None:
+            cmake_cfg = cfg.cmake.get(util.get_os_name())
+        else:
+            cmake_cfg = cfg.cmake.get("cross")
+        if not cmake_cfg:
+            return {}
+        sort_cfg = sorted(cmake_cfg.items(), key=lambda item: int(item[0]))
+        return {int(key): value for key, value in sort_cfg}
 
     @staticmethod
-    def copy_pkg_source_to(staging_dir: Path, pkg: flit_core.common.Module,
-                           symlink: bool = False):
-        """Copy the files of a Python package to the build directory."""
-        for mod_file in pkg.iter_files():
-            rel_path = os.path.relpath(mod_file, pkg.path.parent)
-            dst = staging_dir / rel_path
-            os.makedirs(dst.parent, exist_ok=True)
-            if symlink:
-                dst.symlink_to(mod_file, target_is_directory=False)
-            else:
-                shutil.copy2(mod_file, dst, follow_symlinks=False)
+    def get_wheel_config(cfg: Config):
+        if cfg.cross is None:
+            return cfg.wheel[util.get_os_name()]
+        else:
+            return cfg.wheel["cross"]
 
-    @staticmethod
-    def write_license_files(license, srcdir: Path, distinfo_dir: Path):
-        """Write the LICENSE file from pyproject.toml to the distinfo
-        directory."""
-        if 'text' in license:
-            with (distinfo_dir / 'LICENSE').open('w', encoding='utf-8') as f:
-                f.write(license['text'])
-        elif 'file' in license:
-            assert not Path(license['file']).is_absolute()
-            shutil.copy2(srcdir / license['file'], distinfo_dir)
+    # --- Building sdists -----------------------------------------------------
 
-    @staticmethod
-    def write_entrypoints(distinfo: Path, entrypoints: Dict[str, Dict[str,
-                                                                      str]]):
-        from flit_core.common import write_entry_points
-        with (distinfo / 'entry_points.txt').open('w', encoding='utf-8') as f:
-            write_entry_points(entrypoints, f)
-
-    # --- Editable installs ---------------------------------------------------
-
-    def do_editable_install(self, cfg, paths: BuildPaths,
-                            pkg: flit_core.common.Module):
-        mode = cfg.editable[self.get_os_name()]["mode"]
-        if mode == "wrapper":
-            self.write_editable_wrapper(paths.staging_dir, pkg)
-        elif mode == "hook":
-            self.write_editable_hook(paths.staging_dir, pkg),
-        elif mode == "symlink":
-            paths = self.write_editable_links(paths, pkg)
-        else:
-            assert False, "Invalid editable mode"
-        return paths
-
-    def write_editable_wrapper(self, staging_dir: Path,
-                               pkg: flit_core.common.Module):
-        """Write a fake __init__.py file that points to the development 
-        folder."""
-        tmp_pkg: Path = staging_dir / pkg.name
-        pkgpath = Path(pkg.path)
-        initpath = pkgpath / '__init__.py'
-        os.makedirs(tmp_pkg, exist_ok=True)
-        special_dunders = [
-            '__builtins__', '__cached__', '__file__', '__loader__', '__name__',
-            '__package__', '__path__', '__spec__'
-        ]
-        content = f"""\
-            # First extend the search path with the development folder
-            __spec__.submodule_search_locations.insert(0, {str(pkgpath)!a})
-            # Now manually import the development __init__.py
-            from importlib import util as _util
-            _spec = _util.spec_from_file_location("{pkg.name}",
-                                                  {str(initpath)!a})
-            _mod = _util.module_from_spec(_spec)
-            _spec.loader.exec_module(_mod)
-            # After importing, add its symbols to our global scope
-            _vars = _mod.__dict__.copy()
-            for _k in ['{"','".join(special_dunders)}']: _vars.pop(_k)
-            globals().update(_vars)
-            # Clean up
-            del _k, _spec, _mod, _vars, _util
-            """
-        (tmp_pkg / '__init__.py').write_text(textwrap.dedent(content),
-                                             encoding='utf-8')
-        # Add the py.typed file if it exists, so mypy picks up the stubs for
-        # the C++ extensions
-        py_typed: Path = pkg.path / 'py.typed'
-        if py_typed.exists():
-            shutil.copy2(py_typed, tmp_pkg)
-        # Write a path file so IDEs find the correct files as well
-        (staging_dir / f'{pkg.name}.pth').write_text(str(pkg.path.parent))
-
-    def write_editable_hook(self, staging_dir: Path,
-                            pkg: flit_core.common.Module):
-        # Write a hook that finds the installed compiled extension modules
-        pkg_hook: Path = staging_dir / (pkg.name + '_editable_hook')
-        os.makedirs(pkg_hook, exist_ok=True)
-        content = f"""\
-            import sys, inspect, os
-            from importlib.machinery import PathFinder
-
-            class EditablePathFinder(PathFinder):
-                def __init__(self, name, extra_path):
-                    self.name = name
-                    self.extra_path = extra_path
-                def find_spec(self, name, path=None, target=None):
-                    if name.split('.', 1)[0] != self.name:
-                        return None
-                    path = (path or []) + [self.extra_path]
-                    return super().find_spec(name, path, target)
-
-            def install(name: str):
-                source_path = os.path.abspath(inspect.getsourcefile(EditablePathFinder))
-                source_dir = os.path.dirname(source_path)
-                installed_path = os.path.join(source_dir, '..', name)
-                sys.meta_path.insert(0, EditablePathFinder(name, installed_path))
-
-            install('{pkg.name}')
-            """
-        (pkg_hook / '__init__.py').write_text(textwrap.dedent(content),
-                                              encoding='utf-8')
-        # Write a path file to find the development files
-        content = f"""\
-            {str(pkg.path.parent)}
-            import {pkg.name}_editable_hook"""
-        (staging_dir / f'{pkg.name}.pth').write_text(
-            textwrap.dedent(content))
-        
-    def write_editable_links(self, paths: BuildPaths,
-                             pkg: flit_core.common.Module):
-        paths = copy(paths)
-        cache_dir = paths.source_dir / '.py-build-cmake_cache'
-        cache_dir.mkdir(exist_ok=True)
-        paths.staging_dir = cache_dir / 'editable'
-        shutil.rmtree(paths.staging_dir, ignore_errors=True)
-        paths.staging_dir.mkdir()
-        self.copy_pkg_source_to(paths.staging_dir, pkg, symlink=True)
-        pth_file = paths.pkg_staging_dir / f'{pkg.name}.pth'
-        pth_file.parent.mkdir(exist_ok=True)
-        pth_file.write_text(str(paths.staging_dir))
-        return paths
-
-    # --- Invoking CMake builds -----------------------------------------------
-
-    def run_cmake(self, pkgdir, install_dir, cmake_cfg, cross_cfg,
-                  package_info, native_install_dir):
-        """Configure, build and install using CMake."""
-
-        cmaker = self.get_cmaker(pkgdir,
-                                 install_dir,
-                                 cmake_cfg,
-                                 cross_cfg,
-                                 native_install_dir,
-                                 package_info,
-                                 runner=self.runner)
-
-        cmaker.configure()
-        cmaker.build()
-        cmaker.install()
+    def do_build_sdist(self, sdist_directory, config_settings):
+        # Load metadata
+        src_dir = Path().resolve()
+        pyproject = src_dir / "pyproject.toml"
+        cfg, module = self.read_all_metadata(src_dir, config_settings, self.verbose)
+        pkg_info = self.get_pkg_info(cfg, module)
+
+        # Export dist
+        extra_files = [pyproject, *cfg.referenced_files]
+        sdist_cfg = cfg.sdist["cross" if cfg.cross else util.get_os_name()]
+        sdist_builder = SdistBuilder(
+            module,
+            pkg_info,
+            metadata=cfg.standard_metadata,
+            cfgdir=src_dir,
+            extra_files=extra_files,
+            include_patterns=sdist_cfg.get("include_patterns", []),
+            exclude_patterns=sdist_cfg.get("exclude_patterns", []),
+        )
+        sdist_tar = sdist_builder.build(Path(sdist_directory))
+        return str(Path(sdist_tar).relative_to(sdist_directory))
+
+    # --- CMake builds --------------------------------------------------------
 
     @staticmethod
-    def get_cmaker(pkg_dir: Path, install_dir: Optional[Path], cmake_cfg: dict,
-                   cross_cfg: Optional[dict],
-                   native_install_dir: Optional[Path],
-                   package_info: PackageInfo, **kwargs):
-        toolchain_file = None
+    def get_cmaker(
+        source_dir: Path,
+        build_dir: Path,
+        install_dir: Path | None,
+        cmake_cfg: dict,
+        cross_cfg: dict | None,
+        package_info: PackageInfo,
+        **kwargs,
+    ):
+        # Optionally include the cross-compilation settings
         if cross_cfg:
-            toolchain_file = cross_cfg['toolchain_file']
+            cross_compiling = True
+
+            def cvt_path(x):
+                if x is None:
+                    return None
+                if isinstance(x, str) and not x:
+                    return None
+                assert isinstance(x, (Path, str))
+                return Path(x)
+
+            def python_tag_to_cmake(x: str | None):
+                if x is None:  # If not set, use native interpreter
+                    x = get_interpreter_name()
+                return {
+                    "cp": "Python",
+                    "pp": "PyPy",
+                    "ip": "IronPython",
+                    "jy": "Jython",
+                }.get(x)
+
+            cross_opts = {
+                "toolchain_file": cvt_path(cross_cfg.get("toolchain_file")),
+                "python_prefix": cvt_path(cross_cfg.get("prefix")),
+                "python_library": cvt_path(cross_cfg.get("library")),
+                "python_include_dir": cvt_path(cross_cfg.get("include_dir")),
+                "python_interpreter_id": python_tag_to_cmake(
+                    cross_cfg.get("implementation")
+                ),
+            }
+        else:
+            cross_compiling = False
+            cross_opts = {
+                "toolchain_file": None,
+                "python_prefix": None,
+                "python_library": None,
+                "python_include_dir": None,
+                "python_interpreter_id": None,
+            }
 
         # Add some CMake configure options
-        options = cmake_cfg.get('options', {})
-        if native_install_dir:
-            options['PY_BUILD_CMAKE_NATIVE_INSTALL_DIR:PATH'] = \
-                str(native_install_dir)
-        btype = cmake_cfg.get('build_type')
+        options = cmake_cfg.get("options", {})
+        btype = cmake_cfg.get("build_type")
         if btype:  # -D CMAKE_BUILD_TYPE={type}
-            options['CMAKE_BUILD_TYPE:STRING'] = btype
+            options["CMAKE_BUILD_TYPE:STRING"] = btype
+
+        # Check if we need to pass the Ninja path to CMake
+        generator: str | None = cmake_cfg.get("generator")
+        make_program: Path | None = None
+        if generator is not None and "ninja" in generator.lower():
+            with contextlib.suppress(ImportError):
+                import ninja  # type: ignore[import-not-found]
 
-        # Build folder for each platform
-        build_cfg_name = _BuildBackend.get_build_config_name(cross_cfg)
+                make_program = Path(ninja.BIN_DIR) / "ninja"
+                if platform.system() == "Windows":
+                    make_program = make_program.with_suffix(".exe")
 
         # CMake options
-        return cmake.CMaker(
-            cmake_settings=cmake.CMakeSettings(
-                working_dir=Path(pkg_dir),
+        return CMaker(
+            cmake_settings=CMakeSettings(
+                working_dir=source_dir,
                 source_path=Path(cmake_cfg["source_path"]),
-                build_path=Path(cmake_cfg['build_path']) / build_cfg_name,
-                os=_BuildBackend.get_os_name(),
+                build_path=build_dir,
+                os=util.get_os_name(),
                 find_python=bool(cmake_cfg["find_python"]),
                 find_python3=bool(cmake_cfg["find_python3"]),
+                minimum_required=cmake_cfg["minimum_version"],
                 command=Path("cmake"),
             ),
-            conf_settings=cmake.CMakeConfigureSettings(
+            conf_settings=CMakeConfigureSettings(
                 environment=cmake_cfg.get("env", {}),
-                toolchain_file=toolchain_file,
-                build_type=cmake_cfg.get('build_type'),
+                build_type=cmake_cfg.get("build_type"),
                 options=options,
-                args=cmake_cfg.get('args', []),
-                preset=cmake_cfg.get('preset'),
-                generator=cmake_cfg.get('generator'),
+                args=cmake_cfg.get("args", []),
+                preset=cmake_cfg.get("preset"),
+                generator=generator,
+                make_program=make_program,
+                cross_compiling=cross_compiling,
+                **cross_opts,
             ),
-            build_settings=cmake.CMakeBuildSettings(
-                args=cmake_cfg['build_args'],
-                tool_args=cmake_cfg['build_tool_args'],
-                presets=cmake_cfg.get('build_presets', []),
-                configs=cmake_cfg.get('config', []),
+            build_settings=CMakeBuildSettings(
+                args=cmake_cfg["build_args"],
+                tool_args=cmake_cfg["build_tool_args"],
+                presets=cmake_cfg.get("build_presets", []),
+                configs=cmake_cfg.get("config", []),
             ),
-            install_settings=cmake.CMakeInstallSettings(
-                args=cmake_cfg['install_args'],
-                presets=cmake_cfg.get('install_presets', []),
-                configs=cmake_cfg.get('config', []),
-                components=cmake_cfg.get('install_components', []),
+            install_settings=CMakeInstallSettings(
+                args=cmake_cfg["install_args"],
+                configs=cmake_cfg.get("install_config", []),
+                components=cmake_cfg.get("install_components", []),
                 prefix=install_dir,
             ),
             package_info=package_info,
@@ -571,159 +505,114 @@ def get_cmaker(pkg_dir: Path, install_dir: Optional[Path], cmake_cfg: dict,
 
     # --- Generate stubs ------------------------------------------------------
 
-    def generate_stubs(self, paths: BuildPaths, pkg, cfg: Dict[str, Any]):
+    def generate_stubs(self, paths: BuildPaths, module: Module, cfg: dict[str, Any]):
         """Generate stubs (.pyi) using mypy stubgen."""
-        args = ['stubgen'] + cfg.get('args', [])
-        cfg.setdefault('packages', [pkg.name] if pkg.is_package else [])
-        for p in cfg['packages']:
-            args += ['-p', p]
-        cfg.setdefault('modules', [pkg.name] if not pkg.is_package else [])
-        for m in cfg['modules']:
-            args += ['-m', m]
-        args += cfg.get('files', [])
+        stubs_dir = paths.temp_dir / "stubs"
+        args = ["stubgen", *cfg.get("args", [])]
+        is_package = module.is_package
+        cfg.setdefault("packages", [module.name] if is_package else [])
+        for p in cfg["packages"]:
+            args += ["-p", p]
+        cfg.setdefault("modules", [module.name] if not is_package else [])
+        for m in cfg["modules"]:
+            args += ["-m", m]
+        args += cfg.get("files", [])
         # Add output folder argument if not already specified in cfg['args']
-        if 'args' not in cfg or not ({'-o', '--output'} & set(cfg['args'])):
-            args += ['-o', str(paths.staging_dir)]
+        if "args" not in cfg or not ({"-o", "--output"} & set(cfg["args"])):
+            args += ["-o", str(stubs_dir)]
+        # Add search path argument if not already specified in cfg['args']
+        if "args" not in cfg or "--search-path" not in cfg["args"]:
+            args += ["--search-path", str(paths.staging_dir)]
         env = os.environ.copy()
-        env.setdefault('MYPY_CACHE_DIR', str(paths.temp_dir))
+        env.setdefault("MYPY_CACHE_DIR", str(paths.temp_dir))
         # Call mypy stubgen in a subprocess
-        self.runner.run(args, cwd=pkg.path.parent, check=True, env=env)
-
-    # --- Misc helper functions -----------------------------------------------
-
-    @staticmethod
-    def get_os_name():
-        return {
-            "Linux": "linux",
-            "Windows": "windows",
-            "Darwin": "mac",
-        }[platform.system()]
-
-    @staticmethod
-    def print_config_verbose(cfg):
-        from . import __version__
-        print("\npy-build-cmake (" + __version__ + ")")
-        print("options")
-        print("================================")
-        print("module:")
-        pprint(cfg.module)
-        print("editable:")
-        pprint(cfg.editable)
-        print("sdist:")
-        pprint(cfg.sdist)
-        print("cmake:")
-        pprint(cfg.cmake)
-        print("stubgen:")
-        pprint(cfg.stubgen)
-        print("cross:")
-        pprint(cfg.cross)
-        print("================================\n")
-
-    @staticmethod
-    def normalize_version(version):
-        from distlib.version import NormalizedVersion
-        norm_version = str(NormalizedVersion(version))
-        return norm_version
+        self.runner.run(args, cwd=paths.staging_dir, check=True, env=env)
+        # Copy the stubs to the staging folder (careful not to overwrite
+        # existing stubs generated by CMake)
+        self.copy_stubs(stubs_dir, paths)
+
+    def copy_stubs(self, stubs_dir: Path, paths: BuildPaths):
+        dest = paths.staging_dir
+
+        def stubs_already_exists(dest_path: Path):
+            # We don't want to replace existing .pyi files.
+            dest_pyi = dest_path.with_suffix(".pyi")
+            if dest_pyi.exists():
+                return True
+            # If a directory with the same name already exists, we only
+            # want to copy our .pyi file if the directory does not contain
+            # an __init__.pyi file.
+            dest_dir = dest_path.with_suffix("")
+            dest_dir_init = dest_dir / "__init__.pyi"
+            return dest_dir.is_dir() and dest_dir_init.exists()
+
+        def handle_file(root_path: Path, f: str):
+            rel_path = root_path.relative_to(stubs_dir)
+            src_path = root_path / f
+            dest_path = dest / rel_path / f
+            if not stubs_already_exists(dest_path):
+                logger.debug("Copying generated stub  %s -> %s", src_path, dest_path)
+                shutil.move(str(src_path), str(dest_path))
+            else:
+                logger.info(
+                    "Not copying generated stub file %s because a .pyi "
+                    "file for the same module already exists",
+                    rel_path / f,
+                )
+
+        def handle_dir(root_path: Path, d: str) -> bool:
+            rel_path = root_path.relative_to(stubs_dir)
+            src_path = root_path / d
+            dest_path = dest / rel_path / d
+            dest_pyi = dest_path.with_suffix(".pyi")
+            # If the destination already has stubs for this (sub)module
+            # in a .pyi file, adding the folder as well would only cause
+            # confusion. Ignore the new folder and keep the existing
+            # .pyi file. Don't recurse into the folder either.
+            if dest_pyi.exists():
+                logger.info(
+                    "Not copying generated stub directory %s because a "
+                    ".pyi file for the same module already exists",
+                    rel_path / d,
+                )
+                return False
+            # If there's already a folder with the same name, simply recurse
+            # into it.
+            if dest_path.exists():
+                if dest_path.is_dir():
+                    return True
+                logger.debug(
+                    "Not copying generated stub directory %s because a "
+                    "file with the same name already exists",
+                    rel_path / d,
+                )
+                return False
+            # If there's neither a .pyi file nor a folder with the same
+            # name, we can safely move our folder to the destination, and
+            # there's no need to recurse any further.
+            logger.debug("Copying generated stubs %s -> %s", src_path, dest_path)
+            shutil.move(str(src_path), str(dest_path))
+            return False
 
-    @staticmethod
-    def get_native_tags():
-        """Get the PEP 425 tags for the current platform."""
-        from .tags import get_python_tag, get_abi_tag, get_platform_tag
-        return {
-            'pyver': [get_python_tag()],
-            'abi': [get_abi_tag()],
-            'arch': [get_platform_tag()],
-        }
+        for root, dirs, files in os.walk(stubs_dir):
+            root_path = Path(root)
+            is_pyi = lambda f: Path(f).suffix == ".pyi"
+            for f in filter(is_pyi, files):
+                handle_file(root_path, f)
+            dirs[:] = [d for d in dirs if handle_dir(root_path, d)]
 
-    @staticmethod
-    def get_cross_tags(crosscfg):
-        """Get the PEP 425 tags to use when cross-compiling."""
-        tags = _BuildBackend.get_native_tags()
-        if 'implementation' in crosscfg and 'version' in crosscfg:
-            tags['pyver'] = [crosscfg['implementation'] + crosscfg['version']]
-        if 'abi' in crosscfg:
-            tags['abi'] = [crosscfg['abi']]
-        if 'arch' in crosscfg:
-            tags['arch'] = [crosscfg['arch']]
-        return tags
+    # --- Misc helper functions -----------------------------------------------
 
     @staticmethod
-    def get_build_config_name(cross_cfg):
+    def get_build_config_name(cross_cfg, index: int):
         """Get a string representing the Python version, ABI and architecture,
         used to name the build folder so builds for different versions don't
         interfere."""
-        if cross_cfg:
-            tags = _BuildBackend.get_cross_tags(cross_cfg)
-        else:
-            tags = _BuildBackend.get_native_tags()
-        return '-'.join(map(lambda x: x[0], tags.values()))
-
-    @staticmethod
-    def needs_cross_native_build(cfg):
-        return cfg.cross and 'copy_from_native_build' in cfg.cross
-
-    @staticmethod
-    def iter_files(stagedir):
-        """Iterate over the files contained in the given folder.
-
-        Yields absolute paths - caller may want to make them relative.
-        Excludes any __pycache__ and *.pyc files."""
-
-        # https://github.com/pypa/flit/blob/a4524758604107bde8c77b5816612edb76a604aa/flit_core/flit_core/common.py#L73
-
-        def _include(path):
-            name = os.path.basename(path)
-            return name != '__pycache__' and not name.endswith('.pyc')
-
-        # Ensure we sort all files and directories so the order is stable
-        for dirpath, dirs, files in os.walk(str(stagedir)):
-            for file in sorted(files):
-                full_path = os.path.join(dirpath, file)
-                if _include(full_path):
-                    yield full_path
-
-            dirs[:] = [d for d in sorted(dirs) if _include(d)]
-
-    # --- Helper functions for finding programs like CMake --------------------
-
-    @staticmethod
-    def check_cmake_program(cfg: config.Config, deps: List[str],
-                            runner: CommandRunner):
-        assert cfg.cmake
-        # Do we need to perform a native build?
-        native = not cfg.cross or _BuildBackend.needs_cross_native_build(cfg)
-        native_cfg = cfg.cmake[_BuildBackend.get_os_name()] if native else {}
-        # Do we need to perform a cross build?
-        cross = cfg.cross
-        cross_cfg = cfg.cmake.get('cross', {})
-        # Find the strictest version requirement
-        min_cmake_ver = max(
-            _CMAKE_MINIMUM_REQUIRED,
-            NormalizedVersion(native_cfg.get('minimum_version', '0.0')),
-            NormalizedVersion(cross_cfg.get('minimum_version', '0.0')),
-        )
-        # If CMake in PATH doesn't work or is too old, add it as a build
-        # requirement
-        if not runner.check_program_version('cmake', min_cmake_ver, "CMake"):
-            deps.append("cmake>=" + str(min_cmake_ver))
-
-        # Check if we need Ninja
-        cfgs = []
-        if native: cfgs.append(native_cfg)
-        if cross: cfgs.append(cross_cfg)
-        # Do any of the configs require Ninja as a generator?
-        needs_ninja = lambda c: 'ninja' in c.get('generator', '').lower()
-        need_ninja = any(map(needs_ninja, cfgs))
-        if need_ninja:
-            # If so, check if a working version exists in the PATH, otherwise,
-            # add it as a build requirement
-            if not runner.check_program_version('ninja', None, "Ninja"):
-                deps.append("ninja")
-
-    @staticmethod
-    def check_stubgen_program(deps: List[str], runner: CommandRunner):
-        if not runner.check_program_version('stubgen', None, None, False):
-            deps.append("mypy")
+        tags = get_cross_tags(cross_cfg) if cross_cfg else get_native_tags()
+        name = "-".join(x[0] for x in tags.values())
+        if index != 0:
+            name += f"-{index}"
+        return name
 
 
 _BACKEND = _BuildBackend()
diff --git a/src/py_build_cmake/build_component.py b/src/py_build_cmake/build_component.py
index c9716e6..cd0f0f7 100644
--- a/src/py_build_cmake/build_component.py
+++ b/src/py_build_cmake/build_component.py
@@ -1,19 +1,23 @@
+from __future__ import annotations
+
+import logging
 import tempfile
 from pathlib import Path
-from typing import Any, Dict, List, Optional
-import os
-from pprint import pprint
-
-from . import config
-from .build import _BuildBackend
-from .datastructures import BuildPaths, PackageInfo
-from .cmd_runner import CommandRunner
 
-import flit_core.config
+from .build import _BuildBackend as std_backend
+from .commands.cmd_runner import CommandRunner
+from .common import (
+    ConfigError,
+    PackageInfo,
+    format_and_rethrow_exception,
+)
+from .config import load as config_load
+from .export import metadata as export_metadata
 
+logger = logging.getLogger(__name__)
 
-class _BuildComponentBackend(object):
 
+class _BuildComponentBackend:
     # --- Constructor ---------------------------------------------------------
 
     def __init__(self) -> None:
@@ -27,16 +31,20 @@ def verbose(self):
 
     def get_requires_for_build_wheel(self, config_settings=None):
         """https://www.python.org/dev/peps/pep-0517/#get-requires-for-build-wheel"""
-        self.parse_config_settings(config_settings)
-
-        comp_pyproject = Path('pyproject.toml').resolve()
-        comp_cfg = self.read_component_config(comp_pyproject, config_settings,
-                                              self.verbose)
-        cfg = _BuildBackend.read_config(
-            Path(comp_cfg.component['main_project']) / 'pyproject.toml',
-            config_settings, self.verbose)
-        return _BuildBackend.get_requires_build_project(
-            config_settings, cfg, self.runner)
+        try:
+            self.parse_config_settings(config_settings)
+
+            comp_source_dir = Path().resolve()
+            comp_cfg = self.read_all_metadata(
+                comp_source_dir, config_settings, self.verbose
+            )
+            src_dir = comp_cfg.main_project.resolve()
+            cfg = std_backend.read_config(src_dir, config_settings, self.verbose)
+            return std_backend.get_requires_build_project(
+                config_settings, cfg, self.runner
+            )
+        except Exception as e:
+            format_and_rethrow_exception(e, component=True)
 
     def get_requires_for_build_editable(self, config_settings=None):
         """https://www.python.org/dev/peps/pep-0660/#get-requires-for-build-editable"""
@@ -46,179 +54,149 @@ def get_requires_for_build_sdist(self, config_settings=None):
         """https://www.python.org/dev/peps/pep-0517/#get-requires-for-build-sdist"""
         return []
 
-    def build_wheel(self,
-                    wheel_directory,
-                    config_settings=None,
-                    metadata_directory=None):
+    def build_wheel(
+        self, wheel_directory, config_settings=None, metadata_directory=None
+    ):
         """https://www.python.org/dev/peps/pep-0517/#build-wheel"""
-        assert metadata_directory is None
+        try:
+            assert metadata_directory is None
 
-        # Parse options
-        self.parse_config_settings(config_settings)
+            # Parse options
+            self.parse_config_settings(config_settings)
 
-        # Build wheel
-        with tempfile.TemporaryDirectory() as tmp_build_dir:
-            whl_name = self.build_wheel_in_dir(wheel_directory, tmp_build_dir,
-                                               config_settings)
-        return whl_name
+            # Build wheel
+            with tempfile.TemporaryDirectory() as tmp_build_dir:
+                return self.build_wheel_in_dir(
+                    wheel_directory, tmp_build_dir, config_settings
+                )
+        except Exception as e:
+            format_and_rethrow_exception(e, component=True)
 
-    def build_editable(self,
-                       wheel_directory,
-                       config_settings=None,
-                       metadata_directory=None):
-        raise NotImplementedError(
-            "Editable installation not supported for individual components.")
+    def build_editable(
+        self, wheel_directory, config_settings=None, metadata_directory=None
+    ):
+        msg = "Editable installation not supported for individual components."
+        raise NotImplementedError(msg)
 
     def build_sdist(self, sdist_directory, config_settings=None):
-        raise NotImplementedError(
-            "Source distribution not supported for individual components.")
+        msg = "Source distribution not supported for individual components."
+        raise NotImplementedError(msg)
 
     # --- Parsing config options and metadata ---------------------------------
 
-    def parse_config_settings(self, config_settings: Optional[Dict]):
-        self.runner.verbose = _BuildBackend.is_verbose_enabled(config_settings)
-
-    @staticmethod
-    def read_component_config(pyproject_path: Path,
-                              config_settings: Optional[Dict],
-                              verbose: bool) -> config.ComponentConfig:
-        config_settings = config_settings or {}
+    def parse_config_settings(self, config_settings: dict | None):
         try:
-            cfg = config.read_component_config(pyproject_path)
-            if cfg.dynamic_metadata:
-                raise flit_core.config.ConfigError(
-                    "Dynamic metadata not supported for components.")
-        except flit_core.config.ConfigError as e:
-            e.args = ("\n"
-                      "\n"
-                      "\t❌ Error in user configuration:\n"
-                      "\n"
-                      f"\t\t{e}\n"
-                      "\n", )
-            raise
-        except AssertionError as e:
-            e.args = (
-                "\n"
-                "\n"
-                "\t❌ Internal error while processing the configuration\n"
-                "\t   Please notify the developers: https://github.com/tttapa/py-build-cmake/issues\n"
-                "\n"
-                f"\t\t{e}\n"
-                "\n", )
-            raise
-        if verbose:
-            _BuildComponentBackend.print_config_verbose(cfg)
-        return cfg
+            level = std_backend.get_log_level(config_settings)
+            logging.basicConfig(level=level)
+        except ValueError as e:
+            logger.error("Invalid log level specified", exc_info=e)
+        self.runner.verbose = std_backend.is_verbose_enabled(config_settings)
 
     @staticmethod
     def read_all_metadata(src_dir, config_settings, verbose):
-        from flit_core.common import Metadata
-        cfg = _BuildComponentBackend.read_component_config(
-            src_dir / 'pyproject.toml', config_settings, verbose)
-        md_dict = {'name': cfg.package_name}
-        md_dict.update(cfg.metadata)
-        metadata = Metadata(md_dict)
-        metadata.version = _BuildBackend.normalize_version(metadata.version)
-        return cfg, metadata
+        return config_load.read_full_component_config(
+            src_dir / "pyproject.toml", config_settings, verbose
+        )
 
     # --- Building wheels -----------------------------------------------------
 
-    def build_wheel_in_dir(self,
-                           wheel_directory_,
-                           tmp_build_dir,
-                           config_settings,
-                           editable=False):
+    def build_wheel_in_dir(
+        self, wheel_dir, tmp_build_dir, config_settings, editable=False
+    ):
         """This is the main function that contains all steps necessary to build
         a complete wheel package, including the CMake builds etc."""
         comp_source_dir = Path().resolve()
 
         # Load metadata from the current (component) pyproject.toml file
-        comp_cfg, comp_metadata = self.read_all_metadata(
-            comp_source_dir, config_settings, self.verbose)
-
-        # Set up all paths
-        paths = BuildPaths(
-            source_dir=Path(comp_cfg.component['main_project']),
-            wheel_dir=Path(wheel_directory_),
-            temp_dir=Path(tmp_build_dir),
-            staging_dir=Path(tmp_build_dir) / 'staging',
-            pkg_staging_dir=Path(tmp_build_dir) / 'staging',
+        comp_cfg = self.read_all_metadata(
+            comp_source_dir, config_settings, self.verbose
         )
 
         # Load the config from the main pyproject.toml file
-        cfg = _BuildBackend.read_config(paths.source_dir / 'pyproject.toml',
-                                        config_settings, self.verbose)
-
-        pkg_info = PackageInfo(
-            version=comp_metadata.version,
-            package_name=comp_cfg.package_name,
-            module_name=cfg.module['name'],  # unused, CMake configuration only
+        src_dir = comp_cfg.main_project.resolve()
+        cfg, module = std_backend.read_all_metadata(
+            src_dir, config_settings, self.verbose
         )
+        pkg_info = std_backend.get_pkg_info(comp_cfg, module)
+        cmake_cfg = std_backend.get_cmake_config(cfg)
+
+        # Set up all paths
+        paths = std_backend.get_default_paths(wheel_dir, tmp_build_dir, src_dir, cfg)
 
         # Create dist-info folder
-        distinfo_dir = f'{pkg_info.package_name}-{pkg_info.version}.dist-info'
+        distinfo_dir = f"{pkg_info.norm_name}-{pkg_info.version}.dist-info"
         distinfo_dir = paths.pkg_staging_dir / distinfo_dir
-        os.makedirs(distinfo_dir, exist_ok=True)
-
-        # Write metadata
-        metadata_path = distinfo_dir / 'METADATA'
-        with open(metadata_path, 'w', encoding='utf-8') as f:
-            comp_metadata.write_metadata_file(f)
-        # Write or copy license
-        _BuildBackend.write_license_files(comp_cfg.license, comp_source_dir,
-                                          distinfo_dir)
-        # Write entrypoints/scripts
-        _BuildBackend.write_entrypoints(distinfo_dir, comp_cfg.entrypoints)
-
-        # Configure, build and install the CMake project
-        if cfg.cmake:
-            self.do_cmake_build(comp_cfg, paths, cfg, pkg_info)
+        distinfo_dir.mkdir(parents=True, exist_ok=True)
+
+        # Write metadata, license and entry points to Wheel's distinfo
+        export_metadata.write_metadata(comp_cfg, distinfo_dir)
+        export_metadata.write_license_files(comp_cfg, distinfo_dir)
+        export_metadata.write_entry_points(comp_cfg, distinfo_dir)
+
+        # Build and install the CMake project(s)
+        sort_comp = sorted(comp_cfg.component.items(), key=lambda item: int(item[0]))
+        components = {int(key): value for key, value in sort_comp}
+        for k, component in components.items():
+            if k not in cmake_cfg:
+                msg = f"Index {k} in [tool.py-build-cmake.component] does not "
+                msg += "refer to an exiting CMake configuration in the main "
+                msg += "project."
+                raise ConfigError(msg)
+            cmkcfg = cmake_cfg[k]
+            build_cfg_name = std_backend.get_build_config_name(cfg.cross, k)
+            path = cmkcfg["build_path"]
+            path = str(path).replace("{build_config}", build_cfg_name)
+            build_dir = Path(path)
+            cmaker = self.get_cmaker(
+                paths.source_dir,
+                build_dir,
+                paths.staging_dir,
+                cmkcfg,
+                cfg.cross,
+                pkg_info,
+                component,
+                runner=self.runner,
+            )
+            if not component["install_only"]:
+                cmaker.build()
+            cmaker.install()
 
         # Create wheel
-        whl_name = _BuildBackend.create_wheel(paths, cfg, pkg_info)
-        return whl_name
-
-    # --- Invoking CMake builds -----------------------------------------------
-
-    def do_cmake_build(self, comp_cfg, paths: BuildPaths, cfg, pkg_info):
-        """Configure, build and install using CMake."""
-
-        cmake_cfg, native_cmake_cfg = _BuildBackend.get_cmake_configs(cfg)
-        cmaker = _BuildBackend.get_cmaker(paths.source_dir,
-                                          paths.staging_dir,
-                                          cmake_cfg,
-                                          cfg.cross,
-                                          None,
-                                          pkg_info,
-                                          runner=self.runner)
-
-        comp = comp_cfg.component
-        if 'build_presets' in comp:
-            cmaker.build_settings.presets = comp['build_presets']
-        if 'install_presets' in comp:
-            cmaker.install_settings.presets = comp['install_presets']
-        if 'build_args' in comp:
-            cmaker.build_settings.args = comp['build_args']
-        if 'build_tool_args' in comp:
-            cmaker.build_settings.tool_args = comp['build_tool_args']
-        if 'install_args' in comp:
-            cmaker.install_settings.args = comp['install_args']
-        if 'install_components' in comp:
-            cmaker.install_settings.components = comp['install_components']
-
-        if not comp_cfg.component["install_only"]:
-            cmaker.build()
-        cmaker.install()
-
-    # --- Misc helper functions -----------------------------------------------
+        return std_backend.create_wheel(paths, cfg, cmake_cfg, pkg_info)
+
+    # --- CMake builds --------------------------------------------------------
 
     @staticmethod
-    def print_config_verbose(cfg):
-        print("\npy-build-cmake options")
-        print("======================")
-        print("component:")
-        pprint(cfg.component)
-        print("======================\n")
+    def get_cmaker(
+        source_dir: Path,
+        build_dir: Path,
+        install_dir: Path | None,
+        cmake_cfg: dict,
+        cross_cfg: dict | None,
+        package_info: PackageInfo,
+        component: dict,
+        **kwargs,
+    ):
+        cmaker = std_backend.get_cmaker(
+            source_dir=source_dir,
+            build_dir=build_dir,
+            install_dir=install_dir,
+            cmake_cfg=cmake_cfg,
+            cross_cfg=cross_cfg,
+            package_info=package_info,
+            **kwargs,
+        )
+        if "build_presets" in component:
+            cmaker.build_settings.presets = component["build_presets"]
+        if "build_args" in component:
+            cmaker.build_settings.args = component["build_args"]
+        if "build_tool_args" in component:
+            cmaker.build_settings.tool_args = component["build_tool_args"]
+        if "install_args" in component:
+            cmaker.install_settings.args = component["install_args"]
+        if "install_components" in component:
+            cmaker.install_settings.components = component["install_components"]
+        return cmaker
 
 
 _BACKEND = _BuildComponentBackend()
diff --git a/src/py_build_cmake/cli.py b/src/py_build_cmake/cli.py
index a67373e..48832d6 100644
--- a/src/py_build_cmake/cli.py
+++ b/src/py_build_cmake/cli.py
@@ -1,93 +1,102 @@
-from . import __version__
+from __future__ import annotations
+
 from pathlib import Path
+
 import click
 
+from . import __version__
 
-def cmake_command(directory, build_path, verbose, dry, native, cross, local):
 
-    def get_cmaker():
+def cmake_command(directory, build_path, verbose, dry, cross, local):
+    def get_cmaker(index: int):
         from .build import _BuildBackend as backend
-        from .datastructures import PackageInfo
-        from .cmd_runner import CommandRunner
-        source_dir = Path(directory or '.').resolve()
+        from .commands.cmd_runner import CommandRunner
+
+        src_dir = Path(directory or ".").resolve()
         config_settings = {
             "--cross": list(cross),
             "--local": list(local),
         }
         # Read configuration and package metadata
-        cfg, pkg, metadata = backend.read_all_metadata(source_dir,
-                                                       config_settings,
-                                                       verbose)
+        cfg, module = backend.read_all_metadata(src_dir, config_settings, verbose)
+        pkg_info = backend.get_pkg_info(cfg, module)
+        cmake_cfgs = backend.get_cmake_config(cfg)
+        if not cmake_cfgs:
+            msg = "Not a CMake project ([tool.py-build-cmake.cmake] missing)."
+            raise ValueError(msg)
+        try:
+            cmake_cfg = cmake_cfgs[index]
+        except KeyError as e:
+            msg = "Invalid CMake configuration index (--index). "
+            msg += "Possible values are: " + " ".join(map(str, cmake_cfgs))
+            raise ValueError(msg) from e
 
-        if not cfg.cmake:
-            print("Not a CMake package")
-            return None
+        # Set up all paths
+        build_cfg_name = backend.get_build_config_name(cfg.cross, index)
+        path = build_path or cmake_cfg["build_path"]
+        build_dir = Path(str(path).replace("{build_config}", build_cfg_name))
 
-        pkg_info = PackageInfo(
-            version=metadata.version,
-            package_name=cfg.package_name,
-            module_name=cfg.module["name"],
+        # CMake builder
+        return backend.get_cmaker(
+            src_dir,
+            build_dir,
+            None,
+            cmake_cfg,
+            cfg.cross,
+            pkg_info,
+            runner=CommandRunner(verbose=verbose, dry=dry),
         )
-        # Select the right configuration (native build or cross build)
-        cmake_cfg, native_cmake_cfg = backend.get_cmake_configs(cfg)
-        cmake_cfg = native_cmake_cfg if native else cmake_cfg
-        cross_cfg = None if native else cfg.cross
-        # Override the build folder
-        if build_path is not None:
-            cmake_cfg['build_path'] = str(build_path)
-        # Configure all CMake options
-        return backend.get_cmaker(pkg_dir=source_dir,
-                                  install_dir=None,
-                                  cmake_cfg=cmake_cfg,
-                                  cross_cfg=cross_cfg,
-                                  native_install_dir=None,
-                                  package_info=pkg_info,
-                                  runner=CommandRunner(verbose=verbose,
-                                                       dry=dry))
 
     return get_cmaker
 
 
 @click.group()
-@click.option("-C",
-              "--directory",
-              type=click.Path(exists=True, file_okay=False, dir_okay=True),
-              required=False,
-              help="The directory containing pyproject.toml.")
-@click.option("-B",
-              "--build-path",
-              type=click.Path(exists=False, file_okay=False, dir_okay=True),
-              required=False,
-              default=None,
-              help="Override py-build-cmake's default build folder.")
-@click.option("-V",
-              "--verbose",
-              is_flag=True,
-              help="Print verbose information about the commands being "
-              "executed.")
-@click.option("-n",
-              "--dry",
-              is_flag=True,
-              help="Print the commands without actually invoking CMake.")
-@click.option("--native",
-              is_flag=True,
-              help="When the configuration requests cross-compiling, "
-              "configure for a native build instead. Has no effect otherwise.")
-@click.option("--local",
-              type=click.Path(exists=False, file_okay=True, dir_okay=False),
-              required=False,
-              multiple=True,
-              help="Specifies a toml file that overrides the "
-              "tool.py-build-cmake section of pyproject.toml, "
-              "similar to py-build-cmake.local.toml.")
-@click.option("--cross",
-              type=click.Path(exists=False, file_okay=True, dir_okay=False),
-              required=False,
-              multiple=True,
-              help="Specifies a toml file that overrides the "
-              "tool.py-build-cmake.cross section of pyproject.toml, "
-              "similar to py-build-cmake.cross.toml.")
-@click.version_option(__version__, "-v", "--version")
+@click.option(
+    "-C",
+    "--directory",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    required=False,
+    help="The directory containing pyproject.toml.",
+)
+@click.option(
+    "-B",
+    "--build-path",
+    type=click.Path(exists=False, file_okay=False, dir_okay=True),
+    required=False,
+    default=None,
+    help="Override py-build-cmake's default build folder.",
+)
+@click.option(
+    "-V",
+    "--verbose",
+    is_flag=True,
+    help="Print verbose information about the commands being executed.",
+)
+@click.option(
+    "-n",
+    "--dry",
+    is_flag=True,
+    help="Print the commands without actually invoking CMake.",
+)
+@click.option(
+    "--local",
+    type=click.Path(exists=False, file_okay=True, dir_okay=False),
+    required=False,
+    multiple=True,
+    help="Specifies a toml file that overrides the "
+    "tool.py-build-cmake section of pyproject.toml, "
+    "similar to py-build-cmake.local.toml.",
+)
+@click.option(
+    "--cross",
+    type=click.Path(exists=False, file_okay=True, dir_okay=False),
+    required=False,
+    multiple=True,
+    help="Specifies a toml file that overrides the "
+    "tool.py-build-cmake.cross section of pyproject.toml, "
+    "similar to py-build-cmake.cross.toml.",
+)
+@click.version_option(__version__, "-v", "--version", prog_name="py-build-cmake")
 @click.pass_context
 def cli(ctx: click.Context, **kwargs):
     ctx.obj = cmake_command(**kwargs)
@@ -95,35 +104,65 @@ def cli(ctx: click.Context, **kwargs):
 
 @cli.command(help="Configure the CMake project.")
 @click.pass_obj
-@click.option("--preset", nargs=1, type=str, required=False, metavar="PRESET")
+@click.option(
+    "--preset",
+    nargs=1,
+    type=str,
+    required=False,
+    metavar="PRESET",
+    help="CMake configure preset to use.",
+)
+@click.option(
+    "--use-build-presets",
+    is_flag=True,
+    help="Indicate that a build preset will be used during the build stage. "
+    "This causes py-build-cmake to let CMake pick the build directory during "
+    "configuration, rather than explicitly overriding it.",
+)
+@click.option(
+    "--index",
+    default=0,
+    nargs=1,
+    type=int,
+    required=False,
+    metavar="INDEX",
+    help="Numeric index of the CMake configurations to use. This corresponds "
+    "to the keys used in [tool.py-build-cmake.cmake] in pyproject.toml.",
+)
 @click.argument("args", nargs=-1, required=False)
-def configure(obj, preset, args):
-    cmaker = obj()
+def configure(obj, preset, use_build_presets, args, index):
+    cmaker = obj(index)
     if cmaker is None:
         return
     cmaker.conf_settings.args += args or []
     if preset is not None:
         cmaker.conf_settings.preset = preset
+    if use_build_presets:
+        cmaker.build_settings.presets = [""]
     cmaker.configure()
 
 
 @cli.command(help="Build the CMake project.")
 @click.pass_obj
-@click.option("--preset",
-              nargs=1,
-              multiple=True,
-              type=str,
-              required=False,
-              metavar="PRESET")
-@click.option("--config",
-              nargs=1,
-              multiple=True,
-              type=str,
-              required=False,
-              metavar="CONFIG")
+@click.option(
+    "--preset", nargs=1, multiple=True, type=str, required=False, metavar="PRESET"
+)
+@click.option(
+    "--config", nargs=1, multiple=True, type=str, required=False, metavar="CONFIG"
+)
+@click.option(
+    "--index",
+    default=0,
+    nargs=1,
+    type=int,
+    required=False,
+    metavar="INDEX",
+    help="Numeric index of the CMake configurations to use. This corresponds "
+    "to the keys used in [tool.py-build-cmake.cmake] in pyproject.toml.",
+)
 @click.argument("args", nargs=-1, required=False)
-def build(obj, preset, config, args):
-    cmaker = obj()
+def build(obj, preset, config, args, index):
+    cmaker = obj(index)
     if cmaker is None:
         return
     cmaker.build_settings.args += args or []
@@ -139,35 +178,28 @@ def build(obj, preset, config, args):
 
 @cli.command(help="Install the CMake project.")
 @click.pass_obj
-@click.option("--preset",
-              nargs=1,
-              multiple=True,
-              type=str,
-              required=False,
-              metavar="PRESET")
-@click.option("--config",
-              nargs=1,
-              multiple=True,
-              type=str,
-              required=False,
-              metavar="CONFIG")
-@click.option("--component",
-              nargs=1,
-              multiple=True,
-              type=str,
-              required=False,
-              metavar="COMP")
+@click.option(
+    "--config", nargs=1, multiple=True, type=str, required=False, metavar="CONFIG"
+)
+@click.option(
+    "--component", nargs=1, multiple=True, type=str, required=False, metavar="COMP"
+)
+@click.option(
+    "--index",
+    default=0,
+    nargs=1,
+    type=int,
+    required=False,
+    metavar="INDEX",
+    help="Numeric index of the CMake configurations to use. This corresponds "
+    "to the keys used in [tool.py-build-cmake.cmake] in pyproject.toml.",
+)
 @click.argument("args", nargs=-1, required=False)
-def install(obj, preset, config, component, args):
-    cmaker = obj()
+def install(obj, config, component, args, index):
+    cmaker = obj(index)
     if cmaker is None:
         return
     cmaker.install_settings.args += args or []
-    if preset or config:
-        cmaker.install_settings.presets = []
-        cmaker.install_settings.configs = []
-    if preset:
-        cmaker.install_settings.presets = preset
     if config:
         cmaker.install_settings.configs = config
     if component:
@@ -182,80 +214,214 @@ def config():
 
 @config.command(help="Print documentation for the config file format.")
 @click.option("--md", is_flag=True, help="Use the MarkDown format.")
-@click.option("--component",
-              is_flag=True,
-              help="Documentation for the build_component backend.")
+@click.option(
+    "--component", is_flag=True, help="Documentation for the build_component backend."
+)
 def format(md, component):
-    from .pyproject_options import get_options, get_component_options
-    from .config_options import pth
+    from .config.options.config_path import ConfPath
+    from .config.options.config_reference import ConfigReference
+    from .config.options.pyproject_options import get_component_options, get_options
+
     if md:
         from .help import help_print_md as help_print
     else:
-        from .help import help_print as help_print
-    help_pth = pth('pyproject.toml/tool/py-build-cmake')
-    pr_md = print if md else lambda *args, **kwargs: None
-    pr_tx = lambda *args, **kwargs: None if md else print
+        from .help import help_print
+    help_pth = ConfPath.from_string("pyproject.toml/tool/py-build-cmake")
+    pr_md = print if md else (lambda *args, **kwargs: None)
+    pr_tx = (lambda *args, **kwargs: None) if md else print
     if component:
-        pr_tx("List of py-build-cmake pyproject.toml options for the "
-              "build_component backend:")
-        pr_md("# py-build-cmake component build backend\n"
-              "The `py_build_cmake.build_component` build backend allows "
-              "building packages containing additional binaries that are not "
-              "included with the main distribution.\n")
-        pr_md("A possible use case is distributing debug symbols: these files "
-              "can be large, and most users don't need them, so distributing "
-              "them in a separate package makes sense.\n")
+        pr_tx(
+            "List of py-build-cmake pyproject.toml options for the "
+            "build_component backend:"
+        )
+        pr_md(
+            "# py-build-cmake component build backend\n"
+            "The `py_build_cmake.build_component` build backend allows "
+            "building packages containing additional binaries that are not "
+            "included with the main distribution.\n"
+        )
+        pr_md(
+            "A possible use case is distributing debug symbols: these files "
+            "can be large, and most users don't need them, so distributing "
+            "them in a separate package makes sense.\n"
+        )
         pr_md(
             "See [examples/minimal-debug-component](https://github.com/tttapa/"
             "py-build-cmake/tree/main/examples/minimal-debug-component) "
             "for more information.\n"
         )
-        help_print(get_component_options(Path('/'))[help_pth])
+        pr_md(
+            "The most important option is `main_project`, which is a relative "
+            "path that points to the directory containing the`pyproject.toml` "
+            "of the main package (where all CMake options are defined). "
+            "Next, the options in the `component` section define which CMake "
+            "projects and components should be installed in this component "
+            "package.\n"
+        )
+        opts = get_component_options(Path("/"))
+        root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+        help_print(root_ref.sub_ref(help_pth).config)
 
     else:
         pr_tx("List of py-build-cmake pyproject.toml options:")
         pr_md("# py-build-cmake configuration options\n")
-        pr_md("These options go in the `[tool.py-build-cmake]` section of "
-              "the `pyproject.toml` configuration file.\n")
-        help_print(get_options(Path('/'))[help_pth])
+        pr_md(
+            "These options go in the `[tool.py-build-cmake]` section of "
+            "the `pyproject.toml` configuration file.\n"
+        )
+        opts = get_options(Path("/"))
+        root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+        help_print(root_ref.sub_ref(help_pth).config)
         pr_md("# Local overrides\n")
-        pr_md("Additionally, two extra configuration files can be placed in "
-              "the same directory as `pyproject.toml` to override some "
-              "options for your specific use case:\n\n"
-              "- `py-build-cmake.local.toml`: the options in this file "
-              "override the values in the `tool.py-build-cmake` section of "
-              "`pyproject.toml`.<br/>This is useful if you need specific "
-              "arguments or CMake options to compile the package on your "
-              "system.\n"
-              "- `py-build-cmake.cross.toml`: the options in this file "
-              "override the values in the `tool.py-build-cmake.cross` section "
-              "of `pyproject.toml`.<br/>Useful for cross-compiling the "
-              "package without having to edit the main configuration file.\n")
-        pr_md("# Command line overrides\n")
-        pr_md("Instead of using the `py-build-cmake.local.toml` and "
-              "`py-build-cmake.cross.toml` files, you can also include "
-              "additional config files using command line options:\n\n"
-              "- `--local`: specifies a toml file that overrides the "
-              "`tool.py-build-cmake` section of `pyproject.toml`, "
-              "similar to `py-build-cmake.local.toml`\n"
-              "- `--cross`: specifies a toml file that overrides the "
-              "`tool.py-build-cmake.cross` section of `pyproject.toml`, "
-              "similar to `py-build-cmake.cross.toml`\n\n"
-              "These command line overrides are applied after the "
-              "`py-build-cmake.local.toml` and `py-build-cmake.cross.toml` "
-              "files in the project folder (if any).\n\n"
-              "When using PyPA build, these flags can be specified using "
-              "the `-C` or `--config-setting` flag: \n"
-              "```sh\n"
-              "python -m build . -C--cross=/path/to/my-cross-config.toml\n"
-              "```\n"
-              "The same flag may appear multiple times, for example: \n"
-              "```sh\n"
-              "python -m build . -C--local=conf-A.toml -C--local=conf-B.toml\n"
-              "```\n"
-              "For PyPA pip, you can use the `--config-settings` flag "
-              "instead.")
+        pr_md(
+            "Additionally, two extra configuration files can be placed in "
+            "the same directory as `pyproject.toml` to override some "
+            "options for your specific use case:\n\n"
+            "- `py-build-cmake.local.toml`: the options in this file "
+            "override the values in the `tool.py-build-cmake` section of "
+            "`pyproject.toml`.<br/>This is useful if you need specific "
+            "arguments or CMake options to compile the package on your "
+            "system.\n"
+            "- `py-build-cmake.cross.toml`: the options in this file "
+            "override the values in the `tool.py-build-cmake.cross` section "
+            "of `pyproject.toml`.<br/>Useful for cross-compiling the "
+            "package without having to edit the main configuration file.\n\n"
+            "It is recommended to exclude these files from version control, "
+            "e.g. by adding them to your `.gitignore`.\n\n"
+        )
+        pr_md("# Command-line overrides\n")
+        pr_md(
+            "Instead of using the `py-build-cmake.local.toml` and "
+            "`py-build-cmake.cross.toml` files, you can also include "
+            "additional config files using command-line options:\n\n"
+            "- `--local`: specifies a toml file that overrides the "
+            "`tool.py-build-cmake` section of `pyproject.toml`, "
+            "similar to `py-build-cmake.local.toml`\n"
+            "- `--cross`: specifies a toml file that overrides the "
+            "`tool.py-build-cmake.cross` section of `pyproject.toml`, "
+            "similar to `py-build-cmake.cross.toml`\n\n"
+            "These command-line overrides are applied after the "
+            "`py-build-cmake.local.toml` and `py-build-cmake.cross.toml` "
+            "files in the project folder (if any).\n\n"
+            "When using PyPA build, these flags can be specified using "
+            "the `-C` or `--config-setting` flag: \n"
+            "```sh\n"
+            "python -m build . -C--cross=/path/to/my-cross-config.toml\n"
+            "```\n"
+            "The same flag may appear multiple times. The order for the same "
+            "flag is preserved, but all `--cross` flags are applied after all "
+            "`--local` flags. For example: \n"
+            "```sh\n"
+            "python -m build . -C--local=conf-A.toml -C--local=conf-B.toml\n"
+            "```\n"
+            "For PyPA pip, you can use the `-C` or `--config-settings` flags "
+            "instead.\n\n"
+            "Finally, you can also specify overrides for specific "
+            "configuration options on the command-line, for example:\n"
+            "```sh\n"
+            "python -m build . \\\n"
+            '   -C override=cmake.options.CMAKE_PREFIX_PATH+="/opt/some-package" \\\n'
+            '   -C override=cmake.env.PATH=+(path)"/opt/some-package/bin"\n'
+            "```\n"
+            "The format consists of the configuration option keys (separated) "
+            "by periods, followed by an operator (such as `+=`, see below), "
+            "followed by the value.\n\n"
+            "The following operators are supported:\n"
+            "- `=`: Sets the configuration option regardless of its previous "
+            "value.\n"
+            "- `+=`: Appends the given value to the previous value.\n"
+            "- `=+`: Prepends the given value to the previous value.\n"
+            "- `=-`: Removes the given value from the previous value.\n"
+            "- `=!`: Clears the configuration option if set.\n"
+            "- `+=(path)`: Appends the given value to the previous value, "
+            "joining them with the system's path separator (`:` on Unix, `;` "
+            "on Windows).\n"
+            "- `=+(path)`: Prepends the given value to the previous value, "
+            "joining them with the system's path separator.\n\n"
+            "Values can be specified using a TOML-like syntax, using square "
+            "brackets for lists, and curly braces with equal signs for "
+            "dictionaries. Simple strings can be specified without quotes, "
+            "but quotes are required when including special characters. "
+            "Note the escaping of quotes to prevent the shell from stripping "
+            "them out.\n"
+            "```sh\n"
+            "python -m build . \\\n"
+            '   -C "override=cmake.options.CMAKE_PREFIX_PATH='
+            '[\\"/opt/some-package\\", \\"/another\\"]" \\\n'
+            '   -C "override=cmake.env={MY_PATH = \\"/opt/some-package\\" }" \\\n'
+            '   -C "override=cmake.find_python=true"\n'
+            "```\n\n"
+        )
+        pr_md("# Combining lists\n")
+        pr_md(
+            "Many options are specified as lists of strings. When one of "
+            "these options inherits from or is overridden by another option, "
+            "these lists can be merged in different ways.\n\n"
+            "In the table above, when the data type is `list`, the original "
+            "list of options is simply replaced by the list it is overridden "
+            "by.  \n"
+            "When the data type is `list+`, the value of the overriding "
+            "option is appended to the original value. This is used primarily "
+            "for combining lists of command-line options.\n\n"
+            "If you want full control of what happens when overriding a list "
+            "option, you can use a dictionary with one or more of the "
+            "following keys:\n\n"
+            '  - `"="`: replace the original list by this list (default '
+            "behavior for options of type `list`)\n"
+            '  - `"+"`: append the values of this list to the end of the '
+            "original list (default behavior for options of type `list+`)\n"
+            '  - `"-"`: remove the values in this list from the original '
+            "list (if present)\n"
+            '  - `"prepend"`: prepend the values of this list to the '
+            "beginning of the original list\n\n"
+            "Some examples:\n"
+            """
+```toml
+[cmake]
+build_args = ["--verbose", "--clean-first"]
+[linux.cmake]
+build_args = ["--target", "foo"]
+[windows.cmake]
+build_args = {"-" = ["--verbose"], "+" = ["--target", "bar"]}
+[macos.cmake]
+build_args = {"=" = ["--target", "macos"]}
+```
+"""
+            "Because `linux.cmake` inherits from `cmake`, and because "
+            "`build_args` has type `list+`, this will result in a value of "
+            '`["--verbose", "--clean-first", "--target", "foo"]` for the '
+            "`linux.cmake.build_args` option. The value of "
+            "`windows.cmake.build_args` will be "
+            '`["--clean_first", "--target", "bar"]`, and the value of '
+            '`macos.cmake.build_args` will be `["--target", "macos"]`.\n'
+            """
+```toml
+[cmake]
+config = ["Debug", "Release"]
+[linux.cmake]
+config = ["RelWithDebInfo"]
+[windows.cmake]
+config = {"prepend" = ["RelWithDebInfo"], "-" = ["Debug"], "+" = ["Debug"]}
+```
+"""
+            "The `build_args` option has type `list`, so the value of "
+            '`linux.cmake.config` is simply `["RelWithDebInfo"]`. The value '
+            "of `windows.cmake.config` is "
+            '`["RelWithDebInfo", "Release", "Debug"]`.\n\n'
+            "The same rules also apply to CMake options:\n"
+            """
+```toml
+[cmake.options]
+CMAKE_PREFIX_PATH = "/some/path"
+[linux.cmake.options]
+CMAKE_PREFIX_PATH = {"prepend" = "/some/linux-specific/path"}
+```
+"""
+            "This passes the option "
+            "`-D CMAKE_PREFIX_PATH=/some/linux-specific/path;/some/path` to "
+            "CMake."
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     cli()
diff --git a/src/py_build_cmake/cmake.py b/src/py_build_cmake/cmake.py
deleted file mode 100644
index 29df075..0000000
--- a/src/py_build_cmake/cmake.py
+++ /dev/null
@@ -1,217 +0,0 @@
-from pathlib import Path
-from dataclasses import dataclass
-import os
-from string import Template
-import sys
-from typing import Dict, List, Optional
-import re
-
-from .datastructures import PackageInfo
-from .cmd_runner import CommandRunner
-@dataclass
-class CMakeSettings:
-    working_dir: Path
-    source_path: Path
-    build_path: Path
-    os: str
-    find_python: bool
-    find_python3: bool
-    command: Path = Path("cmake")
-
-
-@dataclass
-class CMakeConfigureSettings:
-    environment: dict
-    toolchain_file: Optional[Path]
-    build_type: Optional[str]
-    options: Dict[str, str]
-    args: List[str]
-    preset: Optional[str]
-    generator: Optional[str]
-
-
-@dataclass
-class CMakeBuildSettings:
-    args: List[str]
-    tool_args: List[str]
-    presets: List[str]
-    configs: List[str]
-
-
-@dataclass
-class CMakeInstallSettings:
-    args: List[str]
-    presets: List[str]
-    configs: List[str]
-    components: List[str]
-    prefix: Optional[Path]
-
-
-class CMaker:
-
-    def __init__(self,
-                 cmake_settings: CMakeSettings,
-                 conf_settings: CMakeConfigureSettings,
-                 build_settings: CMakeBuildSettings,
-                 install_settings: CMakeInstallSettings,
-                 package_info: PackageInfo,
-                 runner: CommandRunner):
-        self.cmake_settings = cmake_settings
-        self.conf_settings = conf_settings
-        self.build_settings = build_settings
-        self.install_settings = install_settings
-        self.package_info = package_info
-        self.runner = runner
-        self.environment: Optional[dict] = None
-
-    def run(self, *args, **kwargs):
-        return self.runner.run(*args, **kwargs)
-
-    def prepare_environment(self):
-        """Copy of the current environment with the variables defined in the
-        user's configuration settings."""
-        if self.environment is None:
-            self.environment = os.environ.copy()
-            if self.conf_settings.environment:
-                for k, v in self.conf_settings.environment.items():
-                    templ = Template(v)
-                    self.environment[k] = templ.substitute(self.environment)
-        return self.environment
-
-    def cross_compiling(self) -> bool:
-        return self.conf_settings.toolchain_file is not None
-
-    def get_configure_options_package(self) -> List[str]:
-        """Flags specific to py-build-cmake, useful in the user's CMake scripts."""
-        return [
-            'PY_BUILD_CMAKE_PACKAGE_VERSION:STRING=' +
-            self.package_info.version,
-            'PY_BUILD_CMAKE_PACKAGE_NAME:STRING=' +
-            self.package_info.package_name,
-            'PY_BUILD_CMAKE_MODULE_NAME:STRING=' +
-            self.package_info.module_name,
-        ]
-
-    def get_configure_options_python(self) -> List[str]:
-        """Flags to help CMake find the right version of Python."""
-        def get_opts(prefix):
-            yield prefix + '_EXECUTABLE:FILEPATH=' + sys.executable
-            if not self.cross_compiling():
-                yield prefix + '_ROOT_DIR:PATH=' + sys.prefix
-                yield prefix + '_FIND_REGISTRY=NEVER'
-                yield prefix + '_FIND_STRATEGY=LOCATION'
-        opts = []
-        if self.cmake_settings.find_python: opts += list(get_opts('Python'))
-        if self.cmake_settings.find_python3: opts += list(get_opts('Python3'))
-        return opts
-
-    def get_configure_options_env(self, env) -> List[str]:
-        """Currently sets CMAKE_OSX_ARCHITECTURES if $ENV{ARCHFLAGS} is set
-        on macOS. This ensures compatibility with cibuildwheel."""
-        opts = []
-        if self.cmake_settings.os == "mac" and "ARCHFLAGS" in env:
-            archs = re.findall(r"-arch (\S+)", env["ARCHFLAGS"])
-            if archs:
-                opts += ['CMAKE_OSX_ARCHITECTURES={}'.format(";".join(archs))]
-        return opts
-
-    def get_configure_options_toolchain(self) -> List[str]:
-        """Sets CMAKE_TOOLCHAIN_FILE."""
-        return [
-            'CMAKE_TOOLCHAIN_FILE:FILEPATH=' +
-            str(self.conf_settings.toolchain_file)
-        ] if self.conf_settings.toolchain_file else []
-
-    def get_configure_options_settings(self) -> List[str]:
-        return [k + '=' + v for k, v in self.conf_settings.options.items()]
-
-    def get_configure_options(self, env) -> List[str]:
-        return (self.get_configure_options_package() +
-                self.get_configure_options_python() +
-                self.get_configure_options_env(env) +
-                self.get_configure_options_toolchain() +
-                self.get_configure_options_settings())
-
-    def get_configure_command(self, env):
-        options = self.get_configure_options(env)
-        cmd = [str(self.cmake_settings.command)]
-        cmd += ['-S', str(self.cmake_settings.source_path)]
-        if self.conf_settings.preset:
-            cmd += ['--preset', self.conf_settings.preset]
-        else:
-            cmd += ['-B', str(self.cmake_settings.build_path)]
-        if self.conf_settings.generator:
-            cmd += ['-G', self.conf_settings.generator]
-        cmd += [f for opt in options for f in ('-D', opt)]
-        cmd += self.conf_settings.args
-        return cmd
-
-    def configure(self):
-        env = self.prepare_environment()
-        cmd = self.get_configure_command(env)
-        cwd = self.cmake_settings.working_dir
-        cwd = str(cwd) if cwd is not None else None
-        self.run(cmd, cwd=cwd, check=True, env=env)
-
-    def iter_presets_configs(self, settings, func):
-        done = False
-        for preset in settings.presets:
-            yield from func(None, preset)
-            done = True
-        for config in settings.configs:
-            yield from func(config, None)
-            done = True
-        if not done:
-            yield from func(None, None)
-
-    def get_build_command(self, config, preset):
-        cmd = [str(self.cmake_settings.command), '--build']
-        if preset is not None:
-            cmd += ['--preset', preset]
-        else:
-            cmd += [str(self.cmake_settings.build_path)]
-        if config is not None:
-            cmd += ['--config', config]
-        if self.build_settings.args:
-            cmd += self.build_settings.args
-        if self.build_settings.tool_args:
-            cmd += ['--'] + self.build_settings.tool_args
-        yield cmd
-
-    def get_build_commands(self):
-        yield from self.iter_presets_configs(self.build_settings,
-                                             self.get_build_command)
-
-    def build(self):
-        env = self.prepare_environment()
-        cwd = self.cmake_settings.working_dir
-        cwd = str(cwd) if cwd is not None else None
-        for cmd in self.get_build_commands():
-            self.run(cmd, cwd=cwd, check=True, env=env)
-
-    def get_install_command(self, config, preset):
-        for component in self.install_settings.components:
-            cmd = [str(self.cmake_settings.command), '--install']
-            if preset is not None:
-                cmd += ['--preset', preset]
-            else:
-                cmd += [str(self.cmake_settings.build_path)]
-            if config is not None:
-                cmd += ['--config', config]
-            if component:
-                cmd += ['--component', component]
-            if self.install_settings.prefix:
-                cmd += ['--prefix', str(self.install_settings.prefix)]
-            if self.install_settings.args:
-                cmd += self.install_settings.args
-            yield cmd
-
-    def get_install_commands(self):
-        yield from self.iter_presets_configs(self.install_settings,
-                                             self.get_install_command)
-    def install(self):
-        env = self.prepare_environment()
-        cwd = self.cmake_settings.working_dir
-        cwd = str(cwd) if cwd is not None else None
-        for cmd in self.get_install_commands():
-            self.run(cmd, cwd=cwd, check=True, env=env)
\ No newline at end of file
diff --git a/src/py_build_cmake/cmd_runner.py b/src/py_build_cmake/cmd_runner.py
deleted file mode 100644
index 3bf3928..0000000
--- a/src/py_build_cmake/cmd_runner.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from pprint import pprint
-from subprocess import CalledProcessError, run as sp_run
-from typing import Optional
-import sys
-import re
-
-from distlib.version import NormalizedVersion  # type: ignore
-
-
-class CommandRunner:
-
-    def __init__(self, verbose=False, dry=False):
-        self.verbose = verbose
-        self.dry = dry
-
-    def run(self, *args, **kwargs):
-        """Wrapper around subprocess.run that optionally prints the command."""
-        if self.verbose:
-            pprint([*args])
-            pprint(kwargs)
-        elif self.dry:
-            from shlex import join
-            print(join(args[0]))
-        if not self.dry:
-            return sp_run(*args, **kwargs)
-
-    def check_program_version(
-        self,
-        program: str,
-        minimum_version: Optional[NormalizedVersion],
-        name: Optional[str],
-        check_version: bool = True,
-    ):
-        """Check if there's a new enough version of the given command available
-        in PATH."""
-        name = name or program
-        try:
-            # Try running the command
-            cmd = [program, '--version'] if check_version else [program, '-h']
-            res = self.run(cmd,
-                           check=True,
-                           capture_output=True,
-                           encoding='utf-8')
-            # Try finding the version
-            if res is not None and check_version:
-                m = re.search(r'\d+(\.\d+){1,}', res.stdout)
-                if not m:
-                    raise RuntimeError(f"Unexpected {name} version output")
-                program_version = NormalizedVersion(m.group(0))
-                if self.verbose: print("Found", name, program_version)
-                # Check if the version is new enough
-                if minimum_version is not None:
-                    if program_version < minimum_version:
-                        raise RuntimeError(f"{name} too old")
-        except CalledProcessError as e:
-            if self.verbose:
-                print(f'{type(e).__module__}.{type(e).__name__}', e, sep=': ')
-                print(e.stdout)
-                print(e.stderr, file=sys.stderr)
-            return False
-        except Exception as e:
-            # If any of that failed, return False
-            if self.verbose:
-                print(f'{type(e).__module__}.{type(e).__name__}', e, sep=': ')
-            return False
-        return True
diff --git a/src/py_build_cmake/commands/cmake.py b/src/py_build_cmake/commands/cmake.py
new file mode 100644
index 0000000..a1fca3b
--- /dev/null
+++ b/src/py_build_cmake/commands/cmake.py
@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import sysconfig
+from dataclasses import dataclass
+from itertools import product
+from pathlib import Path
+from string import Template
+
+from distlib.version import NormalizedVersion  # type: ignore[import-untyped]
+
+from .. import __version__
+from ..common import PackageInfo
+from ..common.util import python_sysconfig_platform_to_cmake_platform_win
+from .cmd_runner import CommandRunner
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CMakeSettings:
+    working_dir: Path
+    source_path: Path
+    build_path: Path
+    os: str
+    find_python: bool
+    find_python3: bool
+    minimum_required: str
+    command: Path = Path("cmake")
+
+
+@dataclass
+class CMakeConfigureSettings:
+    environment: dict
+    build_type: str | None
+    options: dict[str, str]
+    args: list[str]
+    preset: str | None
+    generator: str | None
+    make_program: Path | None
+    cross_compiling: bool
+    toolchain_file: Path | None
+    python_prefix: Path | None
+    python_library: Path | None
+    python_include_dir: Path | None
+    python_interpreter_id: str | None
+
+
+@dataclass
+class CMakeBuildSettings:
+    args: list[str]
+    tool_args: list[str]
+    presets: list[str]
+    configs: list[str]
+
+
+@dataclass
+class CMakeInstallSettings:
+    args: list[str]
+    configs: list[str]
+    components: list[str]
+    prefix: Path | None
+
+
+@dataclass
+class Option:
+    name: str
+    value: str
+    type: str = "STRING"
+    description: str = ""
+
+
+class CMaker:
+    def __init__(
+        self,
+        cmake_settings: CMakeSettings,
+        conf_settings: CMakeConfigureSettings,
+        build_settings: CMakeBuildSettings,
+        install_settings: CMakeInstallSettings,
+        package_info: PackageInfo,
+        runner: CommandRunner,
+    ):
+        self.cmake_settings = cmake_settings
+        self.conf_settings = conf_settings
+        self.build_settings = build_settings
+        self.install_settings = install_settings
+        self.package_info = package_info
+        self.runner = runner
+        self.environment: dict[str, str] | None = None
+
+    def run(self, *args, **kwargs):
+        return self.runner.run(*args, **kwargs)
+
+    def prepare_environment(self):
+        """Copy of the current environment with the variables defined in the
+        user's configuration settings."""
+        if self.environment is None:
+            self.environment = os.environ.copy()
+            self.environment["PY_BUILD_CMAKE_VERSION"] = str(__version__)
+            self.environment["PY_BUILD_CMAKE_BINARY_DIR"] = str(
+                self.cmake_settings.build_path
+            )
+            if self.install_settings.prefix is not None:
+                self.environment["PY_BUILD_CMAKE_INSTALL_PREFIX"] = str(
+                    self.install_settings.prefix
+                )
+            if self.conf_settings.environment:
+                for k, v in self.conf_settings.environment.items():
+                    templ = Template(v)
+                    self.environment[k] = templ.substitute(self.environment)
+        return self.environment
+
+    def cross_compiling(self) -> bool:
+        return self.conf_settings.cross_compiling
+
+    def get_configure_options_package(self) -> list[Option]:
+        """Flags specific to py-build-cmake, useful in the user's CMake scripts."""
+        return [
+            Option("PY_BUILD_CMAKE_VERSION", str(__version__)),
+            Option("PY_BUILD_CMAKE_PACKAGE_VERSION", self.package_info.version),
+            Option("PY_BUILD_CMAKE_PACKAGE_NAME", self.package_info.norm_name),
+            Option("PY_BUILD_CMAKE_MODULE_NAME", self.package_info.module_name),
+        ]
+
+    def get_native_python_abi_tuple(self):
+        cmake_version = self.cmake_settings.minimum_required
+        has_t_flag = NormalizedVersion("3.30") <= NormalizedVersion(cmake_version)
+        dmu = "dmut" if has_t_flag else "dmu"
+        return ";".join("ON" if c in sys.abiflags else "OFF" for c in dmu)
+
+    def get_native_python_implementation(self) -> str | None:
+        return {
+            "cpython": "CPython",
+            "pypy": "PyPy",
+        }.get(sys.implementation.name)
+
+    def get_native_python_hints(self, prefix):
+        """FindPython hints and artifacts for this (native) Python installation."""
+        yield Option(prefix + "_ROOT_DIR", Path(sys.prefix).as_posix())
+        impl = self.get_native_python_implementation()
+        if impl:
+            yield Option(prefix + "_FIND_IMPLEMENTATIONS", impl)
+        if impl == "PyPy":
+            inc = sysconfig.get_path("platinclude")
+            if inc:
+                yield Option(prefix + "_INCLUDE_DIR", Path(inc).as_posix())
+        return
+        # FIND_ABI seems to confuse CMake
+        yield Option(prefix + "_FIND_ABI", self.get_native_python_abi_tuple())
+
+    def get_cross_python_hints(self, prefix):
+        """FindPython hints and artifacts to set when cross-compiling."""
+        if self.conf_settings.python_prefix:
+            pfx = self.conf_settings.python_prefix.as_posix()
+            yield Option(prefix + "_ROOT_DIR", pfx, "PATH")
+        if self.conf_settings.python_library:
+            lib = self.conf_settings.python_library.as_posix()
+            yield Option(prefix + "_LIBRARY", lib, "FILEPATH")
+        if self.conf_settings.python_include_dir:
+            inc = self.conf_settings.python_include_dir.as_posix()
+            yield Option(prefix + "_INCLUDE_DIR", inc, "PATH")
+        if self.conf_settings.python_interpreter_id:
+            id = self.conf_settings.python_interpreter_id
+            yield Option(prefix + "_INTERPRETER_ID", id, "STRING")
+
+    def get_configure_options_python(self) -> list[Option]:
+        """Flags to help CMake find the right version of Python."""
+
+        def get_opts(prefix):
+            executable = Path(sys.executable).as_posix()
+            yield Option(prefix + "_EXECUTABLE", executable, "FILEPATH")
+            yield Option(prefix + "_FIND_REGISTRY", "NEVER")
+            yield Option(prefix + "_FIND_FRAMEWORK", "NEVER")
+            yield Option(prefix + "_FIND_STRATEGY", "LOCATION")
+            yield Option(prefix + "_FIND_VIRTUALENV", "FIRST")
+            if not self.cross_compiling():
+                yield from self.get_native_python_hints(prefix)
+            else:
+                yield from self.get_cross_python_hints(prefix)
+
+        opts = []
+        if self.cmake_settings.find_python:
+            opts += list(get_opts("Python"))
+        if self.cmake_settings.find_python3:
+            opts += list(get_opts("Python3"))
+        return opts
+
+    def get_configure_options_install(self) -> list[Option]:
+        prefix = self.install_settings.prefix
+        if prefix:
+            return [
+                Option("CMAKE_INSTALL_PREFIX", prefix.as_posix(), "PATH"),
+                Option("CMAKE_FIND_NO_INSTALL_PREFIX", "On", "BOOL"),
+            ]
+        return []
+
+    def get_configure_options_make(self) -> list[Option]:
+        """Sets CMAKE_MAKE_PROGRAM."""
+        if self.conf_settings.make_program:
+            opt = Option(
+                "CMAKE_MAKE_PROGRAM",
+                self.conf_settings.make_program.as_posix(),
+                "FILEPATH",
+            )
+            return [opt]
+        return []
+
+    def get_configure_options_toolchain(self) -> list[str]:
+        """Sets CMAKE_TOOLCHAIN_FILE."""
+        return (
+            ["CMAKE_TOOLCHAIN_FILE:FILEPATH=" + str(self.conf_settings.toolchain_file)]
+            if self.conf_settings.toolchain_file
+            else []
+        )
+
+    def get_configure_options_settings(self) -> list[str]:
+        return [k + "=" + v for k, v in self.conf_settings.options.items()]
+
+    def get_configure_options(self) -> list[str]:
+        """Get the list of options (-D) passed to the CMake configure step
+        through the command line."""
+        return (
+            self.get_configure_options_toolchain()
+            + self.get_configure_options_settings()
+        )
+
+    def get_preload_options(self) -> list[Option]:
+        """Get the list of options set in the CMake pre-load script (-C)."""
+        return (
+            self.get_configure_options_package()
+            + self.get_configure_options_make()
+            + self.get_configure_options_python()
+            + self.get_configure_options_install()
+        )
+
+    def write_preload_options(self) -> list[str]:
+        """Write the options into the CMake pre-load script and return the
+        command-line flags that tell CMake to load it."""
+        opts = self.get_preload_options()
+        if not opts:
+            return []
+
+        def fmt_opt(o: Option):
+            return (
+                f'set({o.name} "{o.value}"'
+                f' CACHE {o.type} "{o.description}" FORCE)\n'
+            )
+
+        preload_file = self.cmake_settings.build_path / "py-build-cmake-preload.cmake"
+        version = self.cmake_settings.minimum_required
+        if self.runner.verbose:
+            print("Writing CMake pre-load file")
+            print(f"{preload_file}")
+            print("---------------------------")
+            print(f"cmake_minimum_required(VERSION {version})")
+            for o in opts:
+                print(fmt_opt(o), end="")
+            print("---------------------------\n")
+        if not self.runner.dry:
+            self.cmake_settings.build_path.mkdir(parents=True, exist_ok=True)
+            with preload_file.open("w", encoding="utf-8") as f:
+                f.write(f"cmake_minimum_required(VERSION {version})\n")
+                for o in opts:
+                    f.write(fmt_opt(o))
+        return ["-C", str(preload_file)]
+
+    def get_cmake_generator_platform(self) -> list[str]:
+        win = self.cmake_settings.os == "windows"
+        gen = self.conf_settings.generator
+        vs_gen = win and (not gen or gen.lower().startswith("visual studio"))
+        if vs_gen and not self.cross_compiling():
+            plat = sysconfig.get_platform()
+            cmake_plat = python_sysconfig_platform_to_cmake_platform_win(plat)
+            if cmake_plat:
+                return ["-A", cmake_plat]
+            else:
+                msg = "Unknown platform, CMake generator platform option (-A) will not be set"
+                logger.warning(msg)
+        return []
+
+    def get_configure_command(self):
+        options = self.get_configure_options()
+        cmd = [str(self.cmake_settings.command)]
+        cmd += ["-S", str(self.cmake_settings.source_path)]
+        if self.conf_settings.preset:
+            cmd += ["--preset", self.conf_settings.preset]
+        if not self.conf_settings.preset or not self.build_settings.presets:
+            cmd += ["-B", str(self.cmake_settings.build_path)]
+        if self.conf_settings.generator:
+            cmd += ["-G", self.conf_settings.generator]
+        cmd += self.get_cmake_generator_platform()
+        cmd += self.write_preload_options()
+        cmd += [f for opt in options for f in ("-D", opt)]
+        cmd += self.conf_settings.args
+        return cmd
+
+    def get_working_dir(self):
+        cwd = self.cmake_settings.working_dir
+        return str(cwd) if cwd is not None else None
+
+    def configure(self):
+        env = self.prepare_environment()
+        cmd = self.get_configure_command()
+        cwd = self.get_working_dir()
+        self.run(cmd, cwd=cwd, check=True, env=env)
+
+    def get_build_command(self, config, preset):
+        cmd = [str(self.cmake_settings.command), "--build"]
+        if preset is not None:
+            cmd += ["--preset", preset]
+        else:
+            cmd += [str(self.cmake_settings.build_path)]
+        if config is not None:
+            cmd += ["--config", config]
+        if self.build_settings.args:
+            cmd += self.build_settings.args
+        if self.build_settings.tool_args:
+            cmd += ["--", *self.build_settings.tool_args]
+        return cmd
+
+    def get_build_commands(self):
+        presets = self.build_settings.presets or [None]
+        configs = self.build_settings.configs or [None]
+        for preset, config in product(presets, configs):
+            yield self.get_build_command(config, preset)
+
+    def build(self):
+        env = self.prepare_environment()
+        cwd = self.get_working_dir()
+        for cmd in self.get_build_commands():
+            self.run(cmd, cwd=cwd, check=True, env=env)
+
+    def get_install_command(self, config):
+        for component in self.install_settings.components:
+            cmd = [str(self.cmake_settings.command), "--install"]
+            cmd += [str(self.cmake_settings.build_path)]
+            if self.install_settings.prefix:
+                cmd += ["--prefix", str(self.install_settings.prefix)]
+            if config is not None:
+                cmd += ["--config", config]
+            if component:
+                cmd += ["--component", component]
+            if self.install_settings.args:
+                cmd += self.install_settings.args
+            yield cmd
+
+    def get_install_commands(self):
+        for config in self.install_settings.configs or [None]:
+            yield from self.get_install_command(config)
+
+    def install(self):
+        env = self.prepare_environment()
+        cwd = self.get_working_dir()
+        for cmd in self.get_install_commands():
+            self.run(cmd, cwd=cwd, check=True, env=env)
diff --git a/src/py_build_cmake/commands/cmd_runner.py b/src/py_build_cmake/commands/cmd_runner.py
new file mode 100644
index 0000000..00ad9e9
--- /dev/null
+++ b/src/py_build_cmake/commands/cmd_runner.py
@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import re
+import sys
+from pprint import pprint
+from subprocess import CalledProcessError
+from subprocess import run as sp_run
+
+from distlib.version import NormalizedVersion  # type: ignore[import-untyped]
+
+
+class CommandRunner:
+    def __init__(self, verbose: bool = False, dry: bool = False):
+        self.verbose = verbose
+        self.dry = dry
+
+    def run(self, *args, **kwargs):
+        """Wrapper around subprocess.run that optionally prints the command."""
+        if self.verbose:
+            pprint([*args])
+            pprint(kwargs)
+            print(flush=True)
+        elif self.dry:
+            from shlex import join
+
+            print(join(args[0]))
+        if not self.dry:
+            return sp_run(*args, **kwargs)  # noqa: PLW1510
+        return None
+
+    def check_program_version(
+        self,
+        program: str,
+        minimum_version: NormalizedVersion | None,
+        name: str | None,
+        check_version: bool = True,
+    ):
+        """Check if there's a new enough version of the given command available
+        in PATH."""
+        name = name or program
+        if self.verbose:
+            print(
+                f"Looking for {name} ({program}) version {minimum_version or '0.0'} or later ..."
+            )
+        try:
+            # Try running the command
+            cmd = [program, "--version"] if check_version else [program, "-h"]
+            res = self.run(cmd, check=True, capture_output=True, encoding="utf-8")
+            # Try finding the version
+            if res is not None and check_version:
+                m = re.search(r"\d+(\.\d+){1,}", res.stdout)
+                if not m:
+                    msg = f"Unexpected {name} version output"
+                    raise RuntimeError(msg)
+                program_version = NormalizedVersion(m.group(0))
+                if self.verbose:
+                    print("Found", name, program_version)
+                # Check if the version is new enough
+                if minimum_version is not None and program_version < minimum_version:
+                    msg = f"{name} too old"
+                    raise RuntimeError(msg)
+        except CalledProcessError as e:
+            if self.verbose:
+                print(f"{type(e).__module__}.{type(e).__name__}", e, sep=": ")
+                print(e.stdout)
+                print(e.stderr, file=sys.stderr)
+            return False
+        except Exception as e:
+            # If any of that failed, return False
+            if self.verbose:
+                print(f"{type(e).__module__}.{type(e).__name__}", e, sep=": ")
+            return False
+        return True
diff --git a/src/py_build_cmake/commands/try_run.py b/src/py_build_cmake/commands/try_run.py
new file mode 100644
index 0000000..d64f62c
--- /dev/null
+++ b/src/py_build_cmake/commands/try_run.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any
+
+from distlib.version import NormalizedVersion  # type: ignore[import-untyped]
+
+from ..common import CMAKE_MINIMUM_REQUIRED, Config
+from ..common.util import get_os_name
+from .cmd_runner import CommandRunner
+
+
+def check_cmake_program(cfg: Config, deps: list[str], runner: CommandRunner):
+    assert cfg.cmake
+    # Do we need to perform a native build?
+    native = not cfg.cross
+    native_cfg = cfg.cmake.get(get_os_name(), {}) if native else {}
+    # Do we need to perform a cross build?
+    cross = cfg.cross
+    cross_cfg = cfg.cmake.get("cross", {})
+    cfgs: list[dict[str, Any]] = []
+    if native:
+        cfgs.append(native_cfg)
+    if cross:
+        cfgs.append(cross_cfg)
+    # Find the strictest version requirement
+    min_cmake_ver = max(
+        NormalizedVersion(CMAKE_MINIMUM_REQUIRED),
+        NormalizedVersion(CMAKE_MINIMUM_REQUIRED),  # deliberate, for empty case
+        *(
+            NormalizedVersion(v.get("minimum_version", "0.0"))
+            for c in cfgs
+            for v in c.values()
+        ),
+    )
+    # If CMake in PATH doesn't work or is too old, add it as a build
+    # requirement
+    if not runner.check_program_version("cmake", min_cmake_ver, "CMake"):
+        deps.append("cmake>=" + str(min_cmake_ver))
+
+    # Do any of the configs require Ninja as a generator?
+    need_ninja = any(
+        "ninja" in v.get("generator", "").lower() for c in cfgs for v in c.values()
+    )
+    if need_ninja and not runner.check_program_version("ninja", None, "Ninja"):
+        # If so, check if a working version exists in the PATH, otherwise,
+        # add it as a build requirement
+        deps.append("ninja")
+
+
+def check_stubgen_program(deps: list[str], runner: CommandRunner):
+    if not runner.check_program_version("stubgen", None, None, False):
+        # we need https://github.com/python/mypy/pull/14722
+        deps.append("mypy>=1.4.0")
diff --git a/src/py_build_cmake/common/__init__.py b/src/py_build_cmake/common/__init__.py
new file mode 100644
index 0000000..530b59d
--- /dev/null
+++ b/src/py_build_cmake/common/__init__.py
@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from subprocess import CalledProcessError
+from typing import Any, Sequence
+
+import pyproject_metadata
+
+logger = logging.getLogger(__name__)
+
+CMAKE_MINIMUM_REQUIRED = "3.15"
+
+
+class FormattedErrorMessage(Exception):
+    """Wrapper exception for any error that already has a nicely formatted
+    error message."""
+
+
+class ConfigError(ValueError):
+    """Problem processing the pyproject.toml config"""
+
+
+class ProblemInModule(ValueError):
+    """Problem processing the project's modules"""
+
+
+class NoDocstringError(ProblemInModule):
+    """The module does not contain a docstring that can be used as package
+    description."""
+
+
+class NoVersionError(ProblemInModule):
+    """The module does not contain a __version__."""
+
+
+class InvalidVersion(ProblemInModule):
+    """The __version__ is invalid."""
+
+
+@dataclass
+class Module:
+    """Describes the location and name of a Python package or module"""
+
+    name: str
+    full_path: Path
+    base_path: Path
+    is_package: bool
+    is_namespace: bool
+    is_generated: bool = False
+
+    @property
+    def prefix(self):
+        return self.full_path.parent
+
+    @property
+    def full_file(self):
+        if self.is_package and not self.is_namespace:
+            return self.full_path / "__init__.py"
+        else:
+            return self.full_path
+
+    def iter_files_abs(self):
+        """Iterate over the files contained in this module.
+        Yields absolute paths. Excludes any __pycache__ and *.pyc files.
+        """
+        assert self.is_package or not self.is_namespace
+
+        if self.is_generated:
+            # Generated modules/packages don't exist in the source directory
+            return
+
+        def _include(s: str | Path):
+            p = Path(s)
+            return p.name != "__pycache__" and not p.name.endswith(".pyc")
+
+        if self.is_package:
+            # Ensure we sort all files and directories so the order is stable
+            for dirpath, dirs, files in os.walk(str(self.full_path)):
+                for file in sorted(files):
+                    filepath = Path(dirpath) / file
+                    if _include(filepath):
+                        yield filepath
+                dirs[:] = filter(_include, sorted(dirs))
+        else:
+            yield self.full_file
+
+
+@dataclass
+class Config:
+    """Describes the metadata and configuration settings for the standard
+    build backend."""
+
+    standard_metadata: pyproject_metadata.StandardMetadata
+    package_name: str = field(default="")
+    module: dict[str, str | bool] = field(default_factory=dict)
+    editable: dict[str, dict[str, Any]] = field(default_factory=dict)
+    sdist: dict[str, dict[str, Any]] = field(default_factory=dict)
+    cmake: dict[str, dict[str, Any]] | None = field(default=None)
+    wheel: dict[str, dict[str, Any]] = field(default_factory=dict)
+    stubgen: dict[str, Any] | None = field(default=None)
+    cross: dict[str, Any] | None = field(default=None)
+
+    @property
+    def referenced_files(self) -> list[Path]:
+        metadata = self.standard_metadata
+        res: list[Path] = []
+        if metadata.readme is not None and metadata.readme.file is not None:
+            res += [metadata.readme.file]
+        if metadata.license is not None and metadata.license.file is not None:
+            res += [metadata.license.file]
+        return res
+
+    def check(self):
+        """Check for any incompatible options."""
+        if self.module["namespace"] and any(
+            e["mode"] == "wrapper" for e in self.editable.values()
+        ):
+            msg = "Namespace packages cannot use editable mode 'wrapper'"
+            raise ConfigError(msg)
+        if self.module.get("generated") and any(
+            e["mode"] == "wrapper" for e in self.editable.values()
+        ):
+            msg = "Generated modules/packages cannot use editable mode 'wrapper'"
+            raise ConfigError(msg)
+
+
+@dataclass
+class ComponentConfig:
+    """Describes the metadata and configuration settings for the component
+    build backend."""
+
+    standard_metadata: pyproject_metadata.StandardMetadata
+    main_project: Path
+    package_name: str = field(default="")
+    component: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class PackageInfo:
+    """Describes a Python package (names and version)."""
+
+    version: str
+    package_name: str
+    module_name: str
+
+    @property
+    def norm_name(self):
+        from .util import normalize_name_wheel
+
+        return normalize_name_wheel(self.package_name)
+
+
+@dataclass
+class BuildPaths:
+    """Paths used when building a (Wheel) package."""
+
+    source_dir: Path  # Contains pyproject.toml
+    build_dir: Path  # Usually .py-build-cmake_cache, determined by config
+    wheel_dir: Path  # Where to place the Wheel when done (given by frontend)
+    temp_dir: Path  # Temporary folder for use during build
+    staging_dir: Path  # Where to install the Python modules and data files
+    pkg_staging_dir: Path  # The folder that will be turned into a Wheel
+
+    # Note that staging_dir and pkg_staging_dir can be different, e.g. when
+    # doing an editable install, all Python files and modules are installed to
+    # staging_dir, which is a subfolder of build_dir, and pkg_staging_dir only
+    # contains a .pth file that points to staging_dir
+
+
+@dataclass
+class Command:
+    args: Sequence[str]
+    kwargs: dict[str, Any]
+
+
+def format_and_rethrow_exception(e: BaseException, component=False):
+    """Raises a FormattedErrorMessage from the given exception"""
+    if isinstance(e, FormattedErrorMessage):
+        raise e
+    if isinstance(e, ConfigError):
+        logger.error("Error in user configuration", exc_info=False)
+        comp_arg = " --component" if component else ""
+        msg = (
+            "\n"
+            "\n"
+            "\t\u274C Error in user configuration:\n"
+            "\n"
+            f"\t\t{e}\n"
+            "\n"
+            f"\t   Please run `py-build-cmake config format{comp_arg}` or see "
+            "https://tttapa.github.io/py-build-cmake/Config.html for help.\n"
+        )
+        raise FormattedErrorMessage(msg) from e
+    if isinstance(e, CalledProcessError):
+        logger.error("Subprocess failed", exc_info=False)
+        if e.cmd[:2] == ["cmake", "--build"]:
+            msg = "CMake build failed"
+        elif e.cmd[:2] == ["cmake", "--install"]:
+            msg = "CMake install failed"
+        elif e.cmd[:1] == ["cmake"]:
+            msg = "CMake failed"
+        elif e.cmd[:1] == ["stubgen"]:
+            msg = "Stub generation failed"
+        else:
+            msg = f"Subprocess {e.cmd[0]} failed"
+        msg = (
+            f"\n\n\t\u274C {msg}:\n\n"
+            f"\t\t{e}\n"
+            "\n\t(scroll up for subprocess output, above Python backtrace)"
+        )
+        raise FormattedErrorMessage(msg) from e
+    elif isinstance(e, AssertionError):
+        logger.error("Internal error:", exc_info=e)
+        msg = (
+            "\n"
+            "\n"
+            "\t\u274C Internal error:\n"
+            "\n"
+            f"\t\t{e}\n"
+            "\n"
+            "\t   Please notify the developers: https://github.com/tttapa/py-build-cmake/issues\n"
+        )
+        raise FormattedErrorMessage(msg) from e
+    elif isinstance(e, KeyError):
+        logger.error("Internal KeyError:", exc_info=e)
+        msg = (
+            "\n"
+            "\n"
+            "\t\u274C Internal KeyError:\n"
+            "\n"
+            f"\t\t{e}\n"
+            "\n"
+            "\t   Please notify the developers: https://github.com/tttapa/py-build-cmake/issues\n"
+        )
+        raise FormattedErrorMessage(msg) from e
+    elif isinstance(e, Exception):
+        logger.error("Uncaught exception:", exc_info=e)
+        msg = (
+            "\n"
+            "\n"
+            f"\t\u274C Uncaught exception: {type(e).__name__}\n"
+            "\n"
+            f"\t\t{e}\n"
+            "\n"
+            "\t   Please notify the developers: https://github.com/tttapa/py-build-cmake/issues\n"
+        )
+        raise FormattedErrorMessage(msg) from e
diff --git a/src/py_build_cmake/common/logformat.py b/src/py_build_cmake/common/logformat.py
new file mode 100644
index 0000000..1740966
--- /dev/null
+++ b/src/py_build_cmake/common/logformat.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+
+class GitHubActionsFormatter(logging.Formatter):
+    """Formats warnings etc. for GitHub Actions: https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-a-notice-message"""
+
+    def __init__(self):
+        super().__init__(fmt="%(name)s:%(message)s")
+
+    def format(self, record: logging.LogRecord):
+        s = super().format(record)
+        loc = ""
+        if os.environ.get("GITHUB_REPOSITORY", "").endswith("/py-build-cmake"):
+            p = Path(record.pathname)
+            try:
+                i = len(p.parts) - p.parts[-1::-1].index("py_build_cmake") - 1
+                file = Path("src", *p.parts[i:])
+                loc = f" file={file},line={record.lineno}"
+            except ValueError:
+                pass
+        prefix = {
+            logging.INFO: f"::notice{loc}::",
+            logging.WARNING: f"::warning{loc}::",
+            logging.ERROR: f"::error{loc}::",
+        }.get(record.levelno, record.levelname + ":")
+        return prefix + s
diff --git a/src/py_build_cmake/common/util.py b/src/py_build_cmake/common/util.py
new file mode 100644
index 0000000..9bc6562
--- /dev/null
+++ b/src/py_build_cmake/common/util.py
@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import platform
+import re
+import sys
+from typing import Sequence, cast
+
+if sys.version_info < (3, 8):
+    OSIdentifier = str
+else:
+    from typing import Literal
+
+    OSIdentifier = Literal["linux", "windows", "mac"]
+
+
+def get_os_name() -> OSIdentifier:
+    """Get the name of the current platform."""
+    osname = {
+        "Linux": "linux",
+        "Windows": "windows",
+        "Darwin": "mac",
+    }.get(platform.system())
+    if not osname:
+        msg = "Unsupported platform"
+        raise ValueError(msg)
+    return cast(OSIdentifier, osname)
+
+
+def normalize_name_wheel_pep_427(name: str) -> str:
+    """https://www.python.org/dev/peps/pep-0427/#escaping-and-unicode"""
+    return re.sub(r"[^\w\d.]+", "_", name, flags=re.UNICODE)
+
+
+def normalize_name_wheel(name: str) -> str:
+    """https://packaging.python.org/en/latest/specifications/binary-distribution-format/#escaping-and-unicode"""
+    return re.sub(r"[-_.]+", "_", name).lower()
+
+
+def python_sysconfig_platform_to_cmake_platform_win(
+    plat_name: str | None,
+) -> str | None:
+    """Convert a sysconfig platform string to the corresponding value of
+    https://cmake.org/cmake/help/latest/variable/CMAKE_GENERATOR_PLATFORM.html"""
+    return {
+        None: None,
+        "win32": "Win32",
+        "win-amd64": "x64",
+        "win-arm32": "ARM",
+        "win-arm64": "ARM64",
+    }.get(plat_name)
+
+
+def python_sysconfig_platform_to_cmake_processor_win(
+    plat_name: str | None,
+) -> str | None:
+    """Convert a sysconfig platform string to the corresponding value of
+    https://cmake.org/cmake/help/latest/variable/CMAKE_HOST_SYSTEM_PROCESSOR.html"""
+    # The value of %PROCESSOR_ARCHITECTURE% on Windows
+    return {
+        None: None,
+        "win32": "x86",
+        "win-amd64": "AMD64",
+        "win-arm32": "ARM",
+        "win-arm64": "ARM64",
+    }.get(plat_name)
+
+
+def platform_to_platform_tag(plat: str) -> str:
+    """https://packaging.python.org/en/latest/specifications/platform-compatibility-tags/#platform-tag"""
+    return plat.replace(".", "_").replace("-", "_")
+
+
+def archflags_to_platform_tag(archflags: Sequence[str]) -> str | None:
+    """Convert tuple of CMAKE_OSX_ARCHITECTURES values to the corresponding
+    platform tag https://packaging.python.org/en/latest/specifications/platform-compatibility-tags/#platform-tag
+    """
+    return {
+        ("arm64", "x86_64"): "universal2",
+        ("x86_64",): "x86_64",
+        ("arm64",): "arm64",
+    }.get(tuple(sorted(archflags)))
diff --git a/src/py_build_cmake/config.py b/src/py_build_cmake/config.py
deleted file mode 100644
index 055db4f..0000000
--- a/src/py_build_cmake/config.py
+++ /dev/null
@@ -1,264 +0,0 @@
-from dataclasses import dataclass, field
-import re
-import os
-import warnings
-from typing import Any, Dict, List, Optional, Set, cast
-from pathlib import Path
-from flit_core.config import ConfigError, read_pep621_metadata  # type: ignore
-from flit_core.config import _check_glob_patterns  # type: ignore
-from distlib.util import normalize_name  # type: ignore
-
-from .config_options import ConfigNode, OverrideConfigOption
-from .pyproject_options import get_options, get_cross_path, get_tool_pbc_path, get_component_options
-
-try:
-    import tomllib as toml_  # type: ignore
-except ImportError:
-    import tomli as toml_  # type: ignore
-
-
-@dataclass
-class Config:
-    dynamic_metadata: Set[str] = field(default_factory=set)
-    entrypoints: Dict[str, Dict[str, str]] = field(default_factory=dict)
-    metadata: Dict[str, Any] = field(default_factory=dict)
-    referenced_files: List[str] = field(default_factory=list)
-    package_name: str = field(default='')
-    module: Dict[str, str] = field(default_factory=dict)
-    editable: Dict[str, Any] = field(default_factory=dict)
-    sdist: Dict[str, Dict[str, Any]] = field(default_factory=dict)
-    license: Dict[str, str] = field(default_factory=dict)
-    cmake: Optional[Dict[str, Any]] = field(default=None)
-    stubgen: Optional[Dict[str, Any]] = field(default=None)
-    cross: Optional[Dict[str, Any]] = field(default=None)
-
-
-def read_config(pyproject_path, flag_overrides: Dict[str,
-                                                     List[str]]) -> Config:
-    # Load the pyproject.toml file
-    pyproject_path = Path(pyproject_path)
-    pyproject_folder = pyproject_path.parent
-    pyproject = toml_.loads(pyproject_path.read_text('utf-8'))
-    if 'project' not in pyproject:
-        raise ConfigError('Missing [project] table')
-
-    # Load local override
-    localconfig_fname = 'py-build-cmake.local.toml'
-    localconfig_path = pyproject_folder / localconfig_fname
-    localconfig = None
-    if localconfig_path.exists():
-        localconfig = toml_.loads(localconfig_path.read_text('utf-8'))
-        # treat empty local override as no local override
-        localconfig = localconfig or None
-
-    # Load override for cross-compilation
-    crossconfig_fname = 'py-build-cmake.cross.toml'
-    crossconfig_path = pyproject_folder / crossconfig_fname
-    crossconfig = None
-    if crossconfig_path.exists():
-        crossconfig = toml_.loads(crossconfig_path.read_text('utf-8'))
-        crossconfig = crossconfig or None
-
-    # File names mapping to the actual dict with the config
-    config_files = {
-        "pyproject.toml": pyproject,
-        localconfig_fname: localconfig,
-        crossconfig_fname: crossconfig,
-    }
-    # Additional options for config_options
-    extra_options: List[OverrideConfigOption] = []
-
-    def try_load_local(path: Path):
-        if not path.exists():
-            raise FileNotFoundError(path.absolute())
-        return toml_.loads(path.read_text('utf-8'))
-
-    extra_flag_paths = {
-        '--local': get_tool_pbc_path(),
-        '--cross': get_cross_path(),
-    }
-
-    for flag, targetpath in extra_flag_paths.items():
-        for path in map(Path, flag_overrides[flag]):
-            if not path.is_absolute():
-                path = (Path(os.environ.get("PWD", ".")) / path).resolve()
-            extra_options.append(
-                OverrideConfigOption(
-                    str(path),
-                    "Command line override flag",
-                    targetpath=targetpath,
-                ))
-            config_files[str(path)] = try_load_local(path)
-
-    return check_config(pyproject_path, pyproject, config_files, extra_options)
-
-
-def check_config(pyproject_path, pyproject, config_files, extra_options):
-    # Check the package/module name and normalize it
-    f = 'name'
-    if f in pyproject['project']:
-        normname = normalize_name(pyproject['project'][f])
-        if pyproject['project'][f] != normname:
-            warnings.warn(
-                f"Name changed from {pyproject['project'][f]} to {normname}")
-        pyproject['project'][f] = normname
-
-    # Parse the [project] section for metadata (using flit's parser)
-    flit_cfg = read_pep621_metadata(pyproject['project'], pyproject_path)
-
-    # Create our own config data structure using flit's output
-    cfg = Config()
-    cfg.dynamic_metadata = set(flit_cfg.dynamic_metadata)
-    cfg.entrypoints = flit_cfg.entrypoints
-    cfg.metadata = flit_cfg.metadata
-    cfg.referenced_files = flit_cfg.referenced_files
-    cfg.license = pyproject['project'].setdefault('license', {})
-    cfg.package_name = normalize_name_wheel(cfg.metadata["name"])
-
-    if 'file' in cfg.license and Path(cfg.license['file']).is_absolute():
-        raise ConfigError("License path must be relative")
-
-    opts = get_options(pyproject_path.parent)
-    for o in extra_options:
-        opts.insert(o)
-
-    tree_config = ConfigNode.from_dict(config_files)
-    opts.verify_all(tree_config)
-    opts.override_all(tree_config)
-    opts.inherit_all(tree_config)
-    opts.update_default_all(tree_config)
-    dictcfg = cast(dict, tree_config.to_dict())
-    tool_cfg = dictcfg['pyproject.toml']['tool']['py-build-cmake']
-
-    # Store the module configuration
-    s = 'module'
-    if s in tool_cfg:
-        # Normalize the import and wheel name of the package
-        normname = normalize_name_wheel(tool_cfg[s]['name'])
-        if tool_cfg[s]['name'] != normname:
-            print(f"Name changed from {tool_cfg[s]['name']} to {normname}")
-            # TODO: use logging instead of print
-        tool_cfg[s]['name'] = normname
-        cfg.module = tool_cfg[s]
-    else:
-        assert False, "Missing [tools.py-build-cmake.module] section"
-
-    # Store the editable configuration
-    cfg.editable = {
-        os: tool_cfg[os]['editable']
-        for os in ("linux", "windows", "mac")
-        if os in tool_cfg and 'editable' in tool_cfg[os]
-    }
-
-    # Store the sdist folders (this is based on flit)
-    def get_sdist_cludes(cfg):
-        return {
-            cl + '_patterns': _check_glob_patterns(cfg['sdist'][cl], cl)
-            for cl in ('include', 'exclude')
-        }
-
-    cfg.sdist = {
-        os: get_sdist_cludes(tool_cfg[os])
-        for os in ("linux", "windows", "mac")
-    }
-    s = 'cross'
-    if s in tool_cfg:
-        cfg.sdist.update({
-            'cross': get_sdist_cludes(tool_cfg[s]),
-        })
-
-    # Store the CMake configuration
-    cfg.cmake = {
-        os: tool_cfg[os]['cmake']
-        for os in ("linux", "windows", "mac")
-        if os in tool_cfg and 'cmake' in tool_cfg[os]
-    }
-
-    # Store stubgen configuration
-    s = 'stubgen'
-    if s in tool_cfg:
-        cfg.stubgen = tool_cfg[s]
-
-    # Store the cross compilation configuration
-    s = 'cross'
-    if s in tool_cfg:
-        cfg.cross = tool_cfg[s]
-        f = 'copy_from_native_build'
-        if f in cfg.cross:
-            cfg.cross[f] = _check_glob_patterns(cfg.cross[f], f'cross.{f}')
-        cfg.cmake.update({
-            'cross': cfg.cross.pop('cmake', {}),
-        })
-
-    return cfg
-
-
-@dataclass
-class ComponentConfig:
-    dynamic_metadata: Set[str] = field(default_factory=set)
-    entrypoints: Dict[str, Dict[str, str]] = field(default_factory=dict)
-    metadata: Dict[str, Any] = field(default_factory=dict)
-    referenced_files: List[str] = field(default_factory=list)
-    package_name: str = field(default='')
-    component: Dict[str, Any] = field(default_factory=dict)
-    license: Dict[str, str] = field(default_factory=dict)
-
-
-def read_component_config(pyproject_path) -> ComponentConfig:
-    # Load the pyproject.toml file
-    pyproject_path = Path(pyproject_path)
-    pyproject = toml_.loads(pyproject_path.read_text('utf-8'))
-    if 'project' not in pyproject:
-        raise ConfigError('Missing [project] table')
-
-    # File names mapping to the actual dict with the config
-    config_files = {
-        "pyproject.toml": pyproject,
-    }
-    return check_component_config(pyproject_path, pyproject, config_files)
-
-
-def check_component_config(pyproject_path, pyproject, config_files):
-    # Check the package/module name and normalize it
-    f = 'name'
-    if f in pyproject['project']:
-        normname = normalize_name(pyproject['project'][f])
-        if pyproject['project'][f] != normname:
-            warnings.warn(
-                f"Name changed from {pyproject['project'][f]} to {normname}")
-        pyproject['project'][f] = normname
-
-    # Parse the [project] section for metadata (using flit's parser)
-    flit_cfg = read_pep621_metadata(pyproject['project'], pyproject_path)
-
-    # Create our own config data structure using flit's output
-    cfg = ComponentConfig()
-    cfg.dynamic_metadata = set(flit_cfg.dynamic_metadata)
-    cfg.entrypoints = flit_cfg.entrypoints
-    cfg.metadata = flit_cfg.metadata
-    cfg.referenced_files = flit_cfg.referenced_files
-    cfg.license = pyproject['project'].setdefault('license', {})
-    cfg.package_name = normalize_name_wheel(cfg.metadata["name"])
-
-    if 'file' in cfg.license and Path(cfg.license['file']).is_absolute():
-        raise ConfigError("License path must be relative")
-
-    opts = get_component_options(pyproject_path.parent)
-
-    tree_config = ConfigNode.from_dict(config_files)
-    opts.verify_all(tree_config)
-    opts.override_all(tree_config)
-    opts.inherit_all(tree_config)
-    opts.update_default_all(tree_config)
-    dictcfg = cast(dict, tree_config.to_dict())
-    tool_cfg = dictcfg['pyproject.toml']['tool']['py-build-cmake']
-
-    # Store the component configuration
-    cfg.component = tool_cfg['component']
-
-    return cfg
-
-
-def normalize_name_wheel(name):
-    """https://www.python.org/dev/peps/pep-0427/#escaping-and-unicode"""
-    return re.sub(r"[^\w\d.]+", "_", name, re.UNICODE)
diff --git a/src/py_build_cmake/py.typed b/src/py_build_cmake/config/__init__.py
similarity index 100%
rename from src/py_build_cmake/py.typed
rename to src/py_build_cmake/config/__init__.py
diff --git a/src/py_build_cmake/config/cli_override.lark b/src/py_build_cmake/config/cli_override.lark
new file mode 100644
index 0000000..a6fa193
--- /dev/null
+++ b/src/py_build_cmake/config/cli_override.lark
@@ -0,0 +1,71 @@
+lines: _EOL* line* [_SOL]
+
+?line: [_SOL] option _EOL+
+
+?option: prepend
+       | prepend_path
+       | append
+       | append_path
+       | remove
+       | clear
+       | assign
+
+!?append:       keys OP_APPEND       value      -> full
+!?append_path:  keys OP_APPEND_PATH  value      -> full
+!?remove:       keys OP_REMOVE       value      -> full
+!?prepend:      keys OP_PREPEND      value      -> full
+!?prepend_path: keys OP_PREPEND_PATH value      -> full
+!?clear:        keys OP_CLEAR                   -> full
+!?assign:       keys OP_ASSIGN       value      -> full
+
+OP_APPEND.2:       "+="
+OP_APPEND_PATH.3:  "+=(path)"
+OP_PREPEND.2:      "=+"
+OP_PREPEND_PATH.3: "=+(path)"
+OP_REMOVE.2:       "-="
+OP_CLEAR.2:        "=!"
+OP_ASSIGN.1:       "="
+
+keys: key ("." key)* [_WS]
+
+?value     : object
+           | array
+           | NUMBER
+           | TRUE
+           | FALSE
+           | string
+
+?sub_value : object
+           | array
+           | NUMBER
+           | TRUE
+           | FALSE
+           | string_no_ws
+
+object   : "{" [pair ("," pair)*] "}"
+array    : "[" ( [_WS] sub_value [_WS] ("," [_WS] sub_value [_WS])* ["," [_WS]] )? "]"
+NUMBER.2 : /-?[0-9]+/
+TRUE.2   : "true" | "True"
+FALSE.2  : "false" | "False"
+pair     : [_WS] dict_key [_WS] "=" [_WS] sub_value [_WS]
+
+key          : ESCAPED_STRING               -> escaped_string
+             | UNQUOTED_KEY                 -> unquoted_string
+string       : ESCAPED_STRING               -> escaped_string
+             | UNQUOTED_STRING              -> unquoted_string
+string_no_ws : ESCAPED_STRING               -> escaped_string
+             | UNQUOTED_STRING_NO_WS        -> unquoted_string
+dict_key     : ESCAPED_STRING               -> escaped_string
+             | UNQUOTED_DICT_KEY            -> unquoted_string
+
+_WS: /[ \t\f\r\n]+/
+_SOL: /[ \t]+/
+_EOL: /[ \t\f\r]*\n/
+UNQUOTED_KEY:          /[a-zA-Z0-9_-]*[a-zA-Z0-9_]/
+UNQUOTED_STRING:       /[^"\[\]{}\r\n#]+/
+UNQUOTED_STRING_NO_WS: /[^"\[\]{},\r\n# \t\f]+/
+UNQUOTED_DICT_KEY:     /[^"\[\]{},\r\n# \t\f=]+/
+
+%import common.ESCAPED_STRING
+%import common.SH_COMMENT
+%ignore [_WS] SH_COMMENT
diff --git a/src/py_build_cmake/config/cli_override.py b/src/py_build_cmake/config/cli_override.py
new file mode 100644
index 0000000..11c70eb
--- /dev/null
+++ b/src/py_build_cmake/config/cli_override.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, cast
+
+from lark import Lark, Token, Transformer, v_args
+
+grammar = Path(__file__).with_suffix(".lark").read_text()
+
+
+@dataclass
+class CLIOption:
+    action: str
+    key: tuple[str, ...]
+    value: bool | str | list | dict | float | None
+
+
+class TreeToCLIOption(Transformer):
+    @v_args(inline=True)
+    def escaped_string(self, s: Token):
+        return s[1:-1].encode("raw_unicode_escape").decode("unicode_escape")
+
+    @v_args(inline=True)
+    def unquoted_string(self, s: Token):
+        return s.value
+
+    @v_args(inline=True)
+    def full(self, k, a, v=None):
+        return CLIOption(a.value, k, v)
+
+    lines = list
+    keys = tuple
+
+    array = list
+    pair = tuple
+    object = dict
+
+    NUMBER = int
+    TRUE = lambda self, _: True
+    FALSE = lambda self, _: False
+
+
+cli_parser = Lark(grammar, start="option", parser="lalr", transformer=TreeToCLIOption())
+file_parser = Lark(grammar, start="lines", parser="lalr", transformer=TreeToCLIOption())
+
+
+def parse_cli(s: str) -> CLIOption:
+    return cast(CLIOption, cli_parser.parse(s))
+
+
+def parse_file(s: str) -> list[CLIOption]:
+    return cast(List[CLIOption], file_parser.parse(s))
diff --git a/src/py_build_cmake/config/dynamic.py b/src/py_build_cmake/config/dynamic.py
new file mode 100644
index 0000000..b3648d5
--- /dev/null
+++ b/src/py_build_cmake/config/dynamic.py
@@ -0,0 +1,283 @@
+"""
+The following functions are based on flit_core, under the BSD 3-Clause license:
+
+Copyright (c) 2015, Thomas Kluyver and contributors
+All rights reserved.
+
+BSD 3-clause license:
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+from __future__ import annotations
+
+import ast
+import logging
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+
+import distlib.version  # type: ignore[import-untyped]
+
+from ..common import (
+    ConfigError,
+    InvalidVersion,
+    Module,
+    NoDocstringError,
+    NoVersionError,
+    ProblemInModule,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@contextmanager
+def _module_load_ctx():
+    """Preserve some global state that modules might change at import time.
+
+    - Handlers on the root logger.
+    """
+    logging_handlers = logging.root.handlers[:]
+    try:
+        yield
+    finally:
+        logging.root.handlers = logging_handlers
+
+
+def get_docstring_and_version_via_ast(mod_filename: Path):
+    """
+    Return a tuple like (docstring, version) for the given module,
+    extracted by parsing its AST.
+    """
+    # read as bytes to enable custom encodings
+    with mod_filename.open("rb") as f:
+        node = ast.parse(f.read())
+    version = None
+    for child in node.body:
+        # Only use the version from the given module if it's a simple
+        # string assignment to __version__
+        if (
+            isinstance(child, ast.Assign)
+            and any(
+                isinstance(target, ast.Name) and target.id == "__version__"
+                for target in child.targets
+            )
+            and isinstance(child.value, ast.Str)
+        ):
+            version = child.value.s
+            break
+    return ast.get_docstring(node), version
+
+
+# To ensure we're actually loading the specified file, give it a unique name to
+# avoid any cached import. In normal use we'll only load one module per process,
+# so it should only matter for the tests, but we'll do it anyway.
+_import_i = 0
+
+
+def get_docstring_and_version_via_import(mod_filename: Path):
+    """
+    Return a tuple like (docstring, version) for the given module,
+    extracted by importing the module and pulling __doc__ & __version__
+    from it.
+    """
+    global _import_i  # noqa: PLW0603
+    _import_i += 1
+
+    logger.debug("Loading module %s", mod_filename)
+    from importlib.util import module_from_spec, spec_from_file_location
+
+    mod_name = "py_build_cmake.dummy.import%d" % _import_i
+    spec = spec_from_file_location(mod_name, mod_filename)
+    if spec is None:
+        msg = f"Unable to import '{mod_filename}' (missing spec)"
+        raise ProblemInModule(msg)
+    if spec.loader is None:
+        msg = f"Unable to import '{mod_filename}' (missing loader)"
+        raise ProblemInModule(msg)
+    with _module_load_ctx():
+        m = module_from_spec(spec)
+        # Add the module to sys.modules to allow relative imports to work.
+        # importlib has more code around this to handle the case where two
+        # threads are trying to load the same module at the same time, but Flit
+        # should always be running a single thread, so we won't duplicate that.
+        sys.modules[mod_name] = m
+        try:
+            spec.loader.exec_module(m)
+        finally:
+            sys.modules.pop(mod_name, None)
+
+    docstring = m.__dict__.get("__doc__", None)
+    version = m.__dict__.get("__version__", None)
+    return docstring, version
+
+
+def get_info_from_module(mod_filename: Path, for_fields=("version", "description")):
+    """Load the module/package, get its docstring and __version__"""
+    if not for_fields:
+        return {}
+
+    # What core metadata calls Summary, PEP 621 calls description
+    want_summary = "description" in for_fields
+    want_version = "version" in for_fields
+
+    logger.debug("Loading module %s", mod_filename)
+
+    # Attempt to extract our docstring & version by parsing our target's
+    # AST, falling back to an import if that fails. This allows us to
+    # build without necessarily requiring that our built package's
+    # requirements are installed.
+    docstring, version = get_docstring_and_version_via_ast(mod_filename)
+    if (want_summary and not docstring) or (want_version and not version):
+        docstring, version = get_docstring_and_version_via_import(mod_filename)
+
+    res = {}
+
+    if want_summary:
+        if (not docstring) or not docstring.strip():
+            msg = f"The module '{mod_filename}' is missing a docstring."
+            raise NoDocstringError(msg)
+        res["summary"] = docstring.lstrip().splitlines()[0]
+
+    if want_version:
+        res["version"] = check_version(version, mod_filename)
+
+    return res
+
+
+def check_version(version, filename):
+    """
+    Check whether a given version string match PEP 440, and do normalisation.
+
+    Raise InvalidVersion/NoVersionError with relevant information if
+    version is invalid.
+
+    Log a warning if the version is not canonical with respect to PEP 440.
+
+    Returns the version in canonical PEP 440 format.
+    """
+    if not version:
+        msg = f"Please define a `__version__ = \"x.y.z\"` in your module '{filename}'."
+        raise NoVersionError(msg)
+    if not isinstance(version, str):
+        msg = f"__version__ must be a string, not {type(version)}, in module '{filename}'."
+        raise InvalidVersion(msg)
+
+    try:
+        norm_version = distlib.version.NormalizedVersion(version)
+        version = str(norm_version)
+    except distlib.version.UnsupportedVersionError as e:
+        msg = f"Invalid __version__ in module '{filename}'"
+        raise InvalidVersion(msg) from e
+
+    return version
+
+
+# Own code
+# --------------------------------------------------------------------------- #
+
+from pyproject_metadata import StandardMetadata  # noqa: E402
+
+
+def update_dynamic_metadata(metadata: StandardMetadata, mod_filename: Path | None):
+    if mod_filename is None:
+        if metadata.dynamic:
+            msg = "If no module is specified, dynamic metadata is not allowed"
+            raise ConfigError(msg)
+        return
+    res = get_info_from_module(mod_filename, metadata.dynamic)
+    if "version" in res:
+        metadata.version = res["version"]
+    if "summary" in res:
+        metadata.description = res["summary"]
+    metadata.dynamic = []
+
+
+def find_module(module_metadata: dict, src_dir: Path) -> Module:
+    name: str = module_metadata["name"]
+    base_dir: Path = src_dir / module_metadata["directory"]
+    is_namespace: bool = module_metadata["namespace"]
+    generated: str | None = module_metadata.get("generated")
+
+    # If the module is to be generated later by CMake, don't search for it now
+    if generated:
+        return Module(
+            name=name,
+            # This won't have the right extension, but that's not an issue
+            full_path=base_dir / name,
+            base_path=src_dir,
+            is_package=generated == "package",
+            is_namespace=is_namespace,
+            is_generated=True,
+        )
+
+    # Look for the module
+    dir = lambda p: p.is_dir()
+    file = lambda p: not is_namespace and p.is_file()
+    options = [
+        (base_dir / name, dir),
+        (base_dir / "src" / name, dir),
+        (base_dir / (name + ".py"), file),
+        (base_dir / "src" / (name + ".py"), file),
+    ]
+
+    def check(p: Path, checker):
+        return checker(p)
+
+    found = list(filter(lambda x: check(*x), options))
+
+    if len(found) > 1:
+        msg = f"Module is ambiguous {name}: {', '.join(map(repr, sorted(found)))}"
+        raise ConfigError(msg)
+    elif not found:
+        msg = f"No file/folder found for module {name}"
+        raise ConfigError(msg)
+
+    full_path: Path = found[0][0]
+    is_package = found[0][1] == dir
+
+    if is_package:
+        init_exists = (full_path / "__init__.py").exists()
+        if is_namespace and init_exists:
+            msg = (
+                "Namespace packages should not contain __init__.py " f"(in {full_path})"
+            )
+            raise ConfigError(msg)
+        elif not is_namespace and not init_exists:
+            msg = (
+                f"Missing __init__.py in {full_path}. "
+                "Perhaps you forgot to set "
+                "tool.py-build-cmake.module.namespace=true?"
+            )
+            raise ConfigError(msg)
+
+    return Module(
+        name=name,
+        full_path=full_path,
+        base_path=src_dir,
+        is_package=is_package,
+        is_namespace=is_namespace,
+    )
diff --git a/src/py_build_cmake/config/load.py b/src/py_build_cmake/config/load.py
new file mode 100644
index 0000000..e4d2d0d
--- /dev/null
+++ b/src/py_build_cmake/config/load.py
@@ -0,0 +1,535 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+from copy import copy
+from pathlib import Path, PurePosixPath
+from pprint import pprint
+from typing import Any, Dict, Optional, cast
+
+import pyproject_metadata
+from distlib.util import normalize_name  # type: ignore[import-untyped]
+from lark import LarkError
+
+from .. import __version__
+from ..common import ComponentConfig, Config, ConfigError
+from .cli_override import CLIOption, parse_cli, parse_file
+from .options.config_path import ConfPath
+from .options.config_reference import ConfigReference
+from .options.default import ConfigDefaulter
+from .options.finalize import ConfigFinalizer
+from .options.inherit import ConfigInheritor
+from .options.override import ConfigOverrider
+from .options.pyproject_options import (
+    get_component_options,
+    get_component_path,
+    get_cross_path,
+    get_options,
+    get_tool_pbc_path,
+)
+from .options.value_reference import OverrideAction, OverrideActionEnum, ValueReference
+from .options.verify import ConfigVerifier
+from .quirks import config_quirks
+
+try:
+    import tomllib as toml_  # type: ignore[import,unused-ignore]
+except ImportError:
+    import tomli as toml_  # type: ignore[import,no-redef,unused-ignore]
+
+logger = logging.getLogger(__name__)
+
+
+def read_full_config(
+    pyproject_path: Path,
+    config_settings: dict[str, str | list[str]] | None,
+    verbose: bool,
+) -> Config:
+    config_settings = config_settings or {}
+    overrides, cli_overrides = parse_config_settings_overrides(config_settings, verbose)
+    cfg = read_config(pyproject_path, overrides, cli_overrides)
+    if verbose:
+        print_config_verbose(cfg)
+    return cfg
+
+
+def parse_config_settings_overrides(
+    config_settings: dict[str, str | list[str]], verbose: bool, component: bool = False
+):
+    if verbose:
+        print("Configuration settings:")
+        pprint(config_settings)
+
+    def listify(x: str | list[str]):
+        return x if isinstance(x, list) else [x]
+
+    def get_as_list(key: str):
+        return listify(config_settings.get(key) or [])
+
+    keys = ["component"] if component else ["local", "cross"]
+    cli_overrides = (
+        get_as_list("-o")
+        + get_as_list("o")
+        + get_as_list("override")
+        + get_as_list("--override")
+    )
+    file_overrides = {key: get_as_list("--" + key) + get_as_list(key) for key in keys}
+    if verbose:
+        print("Configuration settings for local and cross-compilation file overrides:")
+        pprint(file_overrides)
+        print("Configuration settings command-line overrides:")
+        pprint(cli_overrides)
+    parsed_cli_overrides = []
+    for o in cli_overrides:
+        try:
+            parsed_cli_overrides.append(parse_cli(o))
+        except LarkError as e:
+            msg = f"Failed to parse command line override: {o}"
+            raise ConfigError(msg) from e
+    return file_overrides, parsed_cli_overrides
+
+
+def try_load_toml(path: Path):
+    try:
+        return toml_.loads(path.read_text("utf-8"))
+    except FileNotFoundError as e:
+        msg = f"Config file {str(path.absolute())!r} not found"
+        raise ConfigError(msg) from e
+    except OSError as e:
+        msg = f"Config file {str(path.absolute())!r} could not be loaded"
+        raise ConfigError(msg) from e
+    except toml_.TOMLDecodeError as e:
+        msg = f"Config file {str(path.absolute())!r} is invalid"
+        raise ConfigError(msg) from e
+
+
+def try_load_pbc(path: Path):
+    try:
+        return parse_file(path.read_text("utf-8"))
+    except FileNotFoundError as e:
+        msg = f"Config file {str(path.absolute())!r} not found"
+        raise ConfigError(msg) from e
+    except OSError as e:
+        msg = f"Config file {str(path.absolute())!r} could not be loaded"
+        raise ConfigError(msg) from e
+    except LarkError as e:
+        msg = f"Config file {str(path.absolute())!r} is invalid"
+        raise ConfigError(msg) from e
+
+
+def load_extra_config_files(flag_overrides, targetpath, config_files, overrides):
+    for path in map(Path, flag_overrides):
+        if path.is_absolute():
+            fullpath = path
+        else:
+            fullpath = (Path(os.environ.get("PWD", ".")) / path).resolve()
+        if path.suffix == ".toml":
+            config = try_load_toml(fullpath)
+            if config:  # Treat empty file as no override
+                config_files[fullpath.as_posix()] = config
+                overrides[ConfPath((fullpath.as_posix(),))] = targetpath
+        elif path.suffix == ".pbc":
+            options = try_load_pbc(fullpath)
+            for i, o in enumerate(options):
+                label = f"{fullpath.as_posix()}[{i+1}]"
+                override = add_cli_override(config_files, o, label, targetpath)
+                overrides.update(override)
+        else:
+            msg = f"Config file {str(path.absolute())!r} "
+            msg += "has an unsupported extension (should be .toml or .pbc)"
+            raise ConfigError(msg)
+
+
+def read_config(
+    pyproject_path: str | Path,
+    flag_overrides: dict[str, list[str]],
+    cli_overrides: list[CLIOption],
+) -> Config:
+    # Load the pyproject.toml file
+    pyproject_path = Path(pyproject_path)
+    pyproject_folder = pyproject_path.parent
+    pyproject: dict[str, Any] = try_load_toml(pyproject_path)
+    if "project" not in pyproject:
+        msg = "Missing [project] table"
+        raise ConfigError(msg)
+
+    # Load local overrides
+    check_if_local_configs_exist(flag_overrides, pyproject_folder)
+
+    # File names mapping to the actual dict with the config
+    config_files: dict[str, dict[str, Any]] = {
+        "pyproject.toml": pyproject,
+    }
+
+    # Additional options for config_options
+    overrides: dict[ConfPath, ConfPath] = {}
+    # What to override
+    extra_flag_paths = {"local": get_tool_pbc_path(), "cross": get_cross_path()}
+
+    # Files specified on the command line
+    for flag, targetpath in extra_flag_paths.items():
+        load_extra_config_files(
+            flag_overrides[flag], targetpath, config_files, overrides
+        )
+
+    # Command-line overrides
+    for i, o in enumerate(cli_overrides):
+        overrides.update(add_cli_override(config_files, o, f"<cli:{i+1}>"))
+
+    return process_config(pyproject_path, config_files, overrides)
+
+
+def check_if_local_configs_exist(flag_overrides, pyproject_folder):
+    localconfig_path = pyproject_folder / "py-build-cmake.local.pbc"
+    if localconfig_path.exists():
+        flag_overrides.setdefault("local", []).insert(0, str(localconfig_path))
+    localconfig_path = localconfig_path.with_suffix(".toml")
+    if localconfig_path.exists():
+        flag_overrides.setdefault("local", []).insert(0, str(localconfig_path))
+    # Load override for cross-compilation
+    crossconfig_path = pyproject_folder / "py-build-cmake.cross.pbc"
+    if crossconfig_path.exists():
+        flag_overrides.setdefault("cross", []).insert(0, str(crossconfig_path))
+    crossconfig_path = crossconfig_path.with_suffix(".toml")
+    if crossconfig_path.exists():
+        flag_overrides.setdefault("cross", []).insert(0, str(crossconfig_path))
+
+
+def add_cli_override(
+    config_files: dict[str, dict[str, Any]],
+    opt: CLIOption,
+    label: str,
+    targetpath: ConfPath | None = None,
+):
+    if targetpath is None:
+        targetpath = get_tool_pbc_path()
+    overrides = {ConfPath((label,)): targetpath}
+    o: dict = config_files.setdefault(label, {})
+    for k in opt.key[:-1]:
+        o = o.setdefault(k, {})
+    o[opt.key[-1]] = OverrideAction(
+        action=OverrideActionEnum(opt.action), values=opt.value
+    )
+    return overrides
+
+
+def process_config(
+    pyproject_path: Path | PurePosixPath,
+    config_files: dict[str, dict[str, Any]],
+    overrides: dict[ConfPath, ConfPath],
+    test: bool = False,
+) -> Config:
+    pyproject = config_files["pyproject.toml"]
+    assert pyproject is not None
+    # Check the package/module name and normalize it
+    f = "name"
+    if f in pyproject["project"]:
+        oldname = pyproject["project"][f]
+        normname = normalize_name(oldname)
+        if oldname != normname:
+            logger.info("Name normalized from %s to %s", oldname, normname)
+        pyproject["project"][f] = normname
+
+    # Parse the [project] section for metadata
+    try:
+        Metadata = pyproject_metadata.StandardMetadata
+        meta = Metadata.from_pyproject(pyproject, pyproject_path.parent)
+    except pyproject_metadata.ConfigurationError as e:
+        raise ConfigError(str(e)) from e
+
+    # Create our own config data structure
+    cfg = Config(meta)
+    cfg.package_name = meta.name
+
+    # py-build-cmake option tree
+    opts = get_options(pyproject_path.parent, test=test)
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), config_files)
+
+    # Verify the configuration and apply the overrides
+    verify_and_override_config(overrides, root_ref, root_val)
+
+    # Tweak the configuration depending on the environment and platform
+    config_quirks(root_val.sub_ref(get_tool_pbc_path()))
+    set_up_os_specific_cross_inheritance(root_ref, root_val)
+
+    # Carry out inheritance between options
+    inherit_default_and_finalize_config(root_ref, root_val)
+    pbc_value_ref = root_val.sub_ref(get_tool_pbc_path())
+
+    # Store the module configuration
+    s = "module"
+    if pbc_value_ref.is_value_set(s):
+        # Normalize the import and wheel name of the package
+        name_path = ConfPath((s, "name"))
+        name = cast(str, pbc_value_ref.get_value(name_path))
+        normname = name.replace("-", "_")
+        pbc_value_ref.set_value(name_path, normname)
+        cfg.module = pbc_value_ref.get_value(s)
+    else:
+        msg = "Missing [tools.py-build-cmake.module] section"
+        raise AssertionError(msg)
+
+    # Store the editable configuration
+    cfg.editable = {
+        os: cast(Dict[str, Any], pbc_value_ref.get_value(ConfPath((os, "editable"))))
+        for os in ("linux", "windows", "mac", "cross")
+        if pbc_value_ref.is_value_set(ConfPath((os, "editable")))
+    }
+
+    # Store the sdist folders (this is based on flit)
+    def get_sdist_cludes(v: ValueReference) -> dict[str, Any]:
+        return {
+            clude + "_patterns": v.get_value(ConfPath(("sdist", clude)))
+            for clude in ("include", "exclude")
+        }
+
+    cfg.sdist = {
+        os: get_sdist_cludes(pbc_value_ref.sub_ref(os))
+        for os in ("linux", "windows", "mac", "cross")
+        if pbc_value_ref.is_value_set(os)
+    }
+
+    # Store the CMake configuration
+    cfg.cmake = {
+        os: cast(Dict[str, Any], pbc_value_ref.get_value(ConfPath((os, "cmake"))))
+        for os in ("linux", "windows", "mac", "cross")
+        if pbc_value_ref.is_value_set(ConfPath((os, "cmake")))
+    }
+    cfg.cmake = cfg.cmake or None
+
+    # Store the Wheel configuration
+    cfg.wheel = {
+        os: cast(Dict[str, Any], pbc_value_ref.get_value(ConfPath((os, "wheel"))))
+        for os in ("linux", "windows", "mac", "cross")
+        if pbc_value_ref.is_value_set(ConfPath((os, "wheel")))
+    }
+
+    # Store stubgen configuration
+    s = "stubgen"
+    if pbc_value_ref.is_value_set(s):
+        cfg.stubgen = pbc_value_ref.get_value(s)
+
+    # Store the cross compilation configuration
+    s = "cross"
+    if pbc_value_ref.is_value_set(s):
+        cfg.cross = copy(cast(Optional[Dict[str, Any]], pbc_value_ref.get_value(s)))
+        if cfg.cross is not None:
+            for k in ("cmake", "wheel", "sdist", "editable"):
+                cfg.cross.pop(k, None)
+
+    # Check for incompatible options
+    cfg.check()
+
+    return cfg
+
+
+def verify_and_override_config(
+    overrides: dict[ConfPath, ConfPath],
+    root_ref: ConfigReference,
+    root_val: ValueReference,
+):
+    root_val.set_value(
+        "pyproject.toml",
+        ConfigVerifier(
+            root=root_ref,
+            ref=root_ref.sub_ref("pyproject.toml"),
+            values=root_val.sub_ref("pyproject.toml"),
+        ).verify(),
+    )
+    for override, target in overrides.items():
+        root_val.set_value(
+            override,
+            ConfigVerifier(
+                root=root_ref,
+                ref=root_ref.sub_ref(target),
+                values=root_val.sub_ref(override),
+            ).verify(),
+        )
+        root_val.set_value_default(target, {})
+        root_val.set_value(
+            target,
+            ConfigOverrider(
+                root=root_ref,
+                ref=root_ref.sub_ref(target),
+                values=root_val.sub_ref(target),
+                new_values=root_val.sub_ref(override),
+            ).override(),
+        )
+
+
+def inherit_default_and_finalize_config(
+    root_ref: ConfigReference, root_val: ValueReference
+):
+    ConfigInheritor(
+        root=root_ref,
+        root_values=root_val,
+    ).inherit()
+    root_val.set_value(
+        "pyproject.toml",
+        ConfigFinalizer(
+            root=root_ref,
+            ref=root_ref.sub_ref("pyproject.toml"),
+            values=root_val.sub_ref("pyproject.toml"),
+        ).finalize(),
+    )
+    ConfigDefaulter(
+        root=root_ref,
+        root_values=root_val,
+        ref=root_ref.sub_ref("pyproject.toml"),
+        value_path=ConfPath.from_string("pyproject.toml"),
+    ).update_default()
+
+
+def set_up_os_specific_cross_inheritance(
+    root_ref: ConfigReference, root_val: ValueReference
+):
+    """Update the cross-compilation configuration to inherit from the
+    corresponding OS-specific configuration."""
+    cross_os = None
+    with contextlib.suppress(KeyError):
+        os_path = get_tool_pbc_path().join("cross").join("os")
+        cross_os = cast(Optional[str], root_val.get_value(os_path))
+
+    if cross_os is not None:
+        for s in ("cmake", "sdist", "editable"):
+            parent = get_tool_pbc_path().join(cross_os).join(s)
+            child = get_cross_path().join(s)
+            root_ref.sub_ref(child).config.inherits = parent
+
+
+def print_config_verbose(cfg: Config):
+    print("\npy-build-cmake (" + __version__ + ")")
+    print("options")
+    print("================================")
+    print("package_name:")
+    print(repr(cfg.package_name))
+    print("module:")
+    pprint(cfg.module)
+    print("editable:")
+    pprint(cfg.editable)
+    print("sdist:")
+    pprint(cfg.sdist)
+    print("cmake:")
+    pprint(cfg.cmake)
+    print("wheel:")
+    pprint(cfg.wheel)
+    print("cross:")
+    pprint(cfg.cross)
+    print("stubgen:")
+    pprint(cfg.stubgen)
+    print("================================\n")
+
+
+def read_full_component_config(
+    pyproject_path: Path,
+    config_settings: dict[str, str | list[str]] | None,
+    verbose: bool,
+) -> ComponentConfig:
+    config_settings = config_settings or {}
+    overrides, cli_overrides = parse_config_settings_overrides(
+        config_settings, verbose, component=True
+    )
+    cfg = read_component_config(pyproject_path, overrides, cli_overrides)
+    if cfg.standard_metadata.dynamic:
+        msg = "Dynamic metadata not supported for components."
+        raise ConfigError(msg)
+    if verbose:
+        print_component_config_verbose(cfg)
+    return cfg
+
+
+def read_component_config(
+    pyproject_path: Path,
+    flag_overrides: dict[str, list[str]],
+    cli_overrides: list[CLIOption],
+) -> ComponentConfig:
+    # Load the pyproject.toml file
+    pyproject_folder = pyproject_path.parent
+    pyproject: dict[str, Any] = try_load_toml(pyproject_path)
+    if "project" not in pyproject:
+        msg = "Missing [project] table"
+        raise ConfigError(msg)
+
+    # Load local overrides
+    check_if_local_configs_exist(flag_overrides, pyproject_folder)
+
+    # File names mapping to the actual dict with the config
+    config_files: dict[str, dict[str, Any]] = {
+        "pyproject.toml": pyproject,
+    }
+
+    # Additional options for config_options
+    overrides: dict[ConfPath, ConfPath] = {}
+    # What to override
+    extra_flag_paths = {"component": get_component_path()}
+
+    # Files specified on the command line
+    for flag, targetpath in extra_flag_paths.items():
+        load_extra_config_files(
+            flag_overrides[flag], targetpath, config_files, overrides
+        )
+
+    # Command-line overrides
+    for i, o in enumerate(cli_overrides):
+        overrides.update(add_cli_override(config_files, o, f"<cli:{i+1}>"))
+
+    return process_component_config(pyproject_path, pyproject, overrides, config_files)
+
+
+def process_component_config(
+    pyproject_path: Path,
+    pyproject: dict[str, Any],
+    overrides: dict[ConfPath, ConfPath],
+    config_files: dict[str, dict[str, Any]],
+):
+    # Check the package/module name and normalize it
+    f = "name"
+    if f in pyproject["project"]:
+        oldname = pyproject["project"][f]
+        normname = normalize_name(oldname)
+        if oldname != normname:
+            logger.info("Name normalized from %s to %s", oldname, normname)
+        pyproject["project"][f] = normname
+
+        # Parse the [project] section for metadata
+    try:
+        meta = pyproject_metadata.StandardMetadata.from_pyproject(
+            pyproject, pyproject_path.parent
+        )
+    except pyproject_metadata.ConfigurationError as e:
+        raise ConfigError(str(e)) from e
+
+    # py-build-cmake option tree
+    opts = get_component_options(pyproject_path.parent)
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), config_files)
+
+    # Verify the configuration and apply the overrides
+    verify_and_override_config(overrides, root_ref, root_val)
+
+    # Carry out inheritance between options
+    inherit_default_and_finalize_config(root_ref, root_val)
+    pbc_value_ref = root_val.sub_ref(get_tool_pbc_path())
+
+    # Store the component configuration
+    main_project = pbc_value_ref.get_value("main_project")
+    assert isinstance(main_project, Path)
+    cfg = ComponentConfig(meta, main_project)
+    cfg.package_name = meta.name
+    cfg.component = pbc_value_ref.get_value("component")
+
+    return cfg
+
+
+def print_component_config_verbose(cfg: ComponentConfig):
+    print("\npy-build-cmake (" + __version__ + ")")
+    print("options")
+    print("================================")
+    print("package_name:")
+    print(repr(cfg.package_name))
+    print("main_project:")
+    print(repr(cfg.main_project.as_posix()))
+    print("component:")
+    pprint(cfg.component)
+    print("================================\n")
diff --git a/src/py_build_cmake/config/options/__init__.py b/src/py_build_cmake/config/options/__init__.py
new file mode 100644
index 0000000..0fd1aa6
--- /dev/null
+++ b/src/py_build_cmake/config/options/__init__.py
@@ -0,0 +1,31 @@
+from .config_option import ConfigOption
+from .config_path import ConfPath
+from .config_reference import ConfigReference
+from .default import (
+    ConfigDefaulter,
+    DefaultValueValue,
+    MissingDefaultError,
+    NoDefaultValue,
+    RefDefaultValue,
+    RequiredValue,
+)
+from .inherit import ConfigInheritor
+from .override import ConfigOverrider
+from .value_reference import ValueReference
+from .verify import ConfigVerifier
+
+__all__ = [
+    "ConfigOption",
+    "ConfPath",
+    "ConfigReference",
+    "ConfigDefaulter",
+    "DefaultValueValue",
+    "MissingDefaultError",
+    "NoDefaultValue",
+    "RefDefaultValue",
+    "RequiredValue",
+    "ConfigInheritor",
+    "ConfigOverrider",
+    "ValueReference",
+    "ConfigVerifier",
+]
diff --git a/src/py_build_cmake/config/options/bool.py b/src/py_build_cmake/config/options/bool.py
new file mode 100644
index 0000000..ee2077c
--- /dev/null
+++ b/src/py_build_cmake/config/options/bool.py
@@ -0,0 +1,24 @@
+from ...common import ConfigError
+from .config_option import ConfigOption
+from .value_reference import OverrideActionEnum, ValueReference
+
+
+class BoolConfigOption(ConfigOption):
+    def get_typename(self, md: bool = False):
+        return "bool"
+
+    def override(self, old_value, new_value):
+        return new_value.values
+
+    def verify(self, values: ValueReference):
+        if values.values is None:
+            return None
+        if values.action not in (OverrideActionEnum.Assign, OverrideActionEnum.Default):
+            msg = f"Option {values.value_path} of type {self.get_typename()} "
+            msg += f"does not support operation {values.action.value}"
+            raise ConfigError(msg)
+        elif not isinstance(values.values, bool):
+            msg = f"Type of {values.value_path} should be {bool}, "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+        return values.values
diff --git a/src/py_build_cmake/config/options/cmake_opt.py b/src/py_build_cmake/config/options/cmake_opt.py
new file mode 100644
index 0000000..fa6da5c
--- /dev/null
+++ b/src/py_build_cmake/config/options/cmake_opt.py
@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+import logging
+from copy import copy, deepcopy
+from dataclasses import dataclass
+from typing import List, Union, cast
+
+from ...common import ConfigError
+from .config_option import ConfigOption
+from .config_path import ConfPath
+from .value_reference import OverrideActionEnum, ValueReference
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CMakeOption:
+    clear: bool = False
+    value: list[str | bool] | None = None
+    append: list[str | bool] | None = None
+    prepend: list[str | bool] | None = None
+    remove: list[str | bool] | None = None
+    datatype: str | None = None
+    strict: bool = False
+
+    @classmethod
+    def create(cls, x, datatype=None):
+        assert datatype is None or isinstance(datatype, str)
+        if isinstance(x, list):
+            assert all(isinstance(e, (bool, str)) for e in x)
+            return cls(value=x, datatype=datatype)
+        assert isinstance(x, (bool, str))
+        return cls(value=[x], datatype=datatype)
+
+    @classmethod
+    def _from_dict(cls, x: dict[str, str | bool | list[str | bool]], pth: ConfPath):
+        opt = cls()
+        if "=" in x:
+            assert "value" not in x
+            x["value"] = x.pop("=")
+        if "+" in x:
+            assert "append" not in x
+            x["append"] = x.pop("+")
+        if "-" in x:
+            assert "remove" not in x
+            x["remove"] = x.pop("-")
+        all_bool = True
+        nonempty = False
+        # Preserve lists and convert all values to singletons
+        for k in ("value", "append", "remove", "prepend"):
+            if k not in x:
+                continue
+            v = x.pop(k)
+            v = v if isinstance(v, list) else [v]
+            if not all(isinstance(b, bool) for b in v):
+                all_bool = False
+            if len(v) > 0:
+                nonempty = True
+            setattr(opt, k, v)
+        # Determine the data type
+        datatype = x.pop("type", None)
+        if datatype is None and all_bool and nonempty:
+            datatype = "BOOL"
+        if datatype is not None and not isinstance(datatype, str):
+            msg = f'Error in {pth}: Type of "type" should be str, '
+            msg += f"not {type(datatype)}"
+            raise ConfigError(msg)
+        opt.datatype = datatype
+        # Check if the data type should be checked in strict mode or not
+        strict = x.pop("strict", True)
+        if not isinstance(strict, bool):
+            msg = f'Error in {pth}: Type of "strict" should be bool, '
+            msg += f"not {type(strict)}"
+            raise ConfigError(msg)
+        opt.strict = strict
+        # Check if there are any unused keys left
+        assert not x
+        return opt
+
+    @classmethod
+    def from_values(cls, values: ValueReference):
+        val = values.values
+        if values.action == OverrideActionEnum.Clear:
+            assert val is None
+            return cls(clear=True)
+        if isinstance(val, dict):
+            return cls._from_dict(val, values.value_path)
+        datatype = None
+        if isinstance(val, bool):
+            val = [val]
+            datatype = "BOOL"
+        elif isinstance(val, str):
+            val = [val]
+        elif isinstance(val, list):
+            assert all(isinstance(b, (str, bool)) for b in val)
+            all_bool = all(isinstance(b, bool) for b in val)
+            nonempty = len(val) > 0
+            if all_bool and nonempty:
+                datatype = "BOOL"
+        else:
+            msg = f"Invalid type {type(val)}"
+            raise AssertionError(msg)
+        val = cast(List[Union[str, bool]], val)
+        if values.action in (OverrideActionEnum.Default, OverrideActionEnum.Assign):
+            return cls(value=val, datatype=datatype)
+        if values.action == OverrideActionEnum.Remove:
+            return cls(remove=val, datatype=datatype)
+        if values.action == OverrideActionEnum.Append:
+            return cls(append=val, datatype=datatype)
+        if values.action == OverrideActionEnum.Prepend:
+            return cls(prepend=val, datatype=datatype)
+        msg = f"Invalid action {values.action}"
+        raise AssertionError(msg)
+
+    @staticmethod
+    def _combine_types(
+        a: CMakeOption,
+        b: CMakeOption,
+        strict: bool,
+        a_path: ConfPath,
+        b_path: ConfPath,
+    ) -> str | None:
+        def report(msg):
+            if not strict:
+                logger.warning(msg)
+                return b.datatype
+            msg = f'{msg} (use "strict" = false to ignore)'
+            raise ConfigError(msg)
+
+        if b.datatype is None:
+            return a.datatype
+        if a.datatype is None:
+            return b.datatype
+        if a.datatype == b.datatype:
+            return b.datatype
+        msg = "Incompatible types when overriding or inheriting CMake settings"
+        # Cannot override these by other types
+        if a.datatype in ("BOOL", "STRING", "FILEPATH"):
+            return report(f"{msg}: {a.datatype} ({a_path}) and {b.datatype} ({b_path})")
+        # PATH can be made more specific to FILEPATH
+        if a.datatype == "PATH" and b.datatype != "FILEPATH":
+            return report(f"{msg}: {a.datatype} ({a_path}) and {b.datatype} ({b_path})")
+        return b.datatype
+
+    def override(self, new: CMakeOption):
+        # Clearing always propagates
+        if new.clear:
+            return copy(new)
+        old = copy(self)
+        # If we're overriding with a value, the old value is not used
+        if new.value is not None:
+            old.value = new.value
+            old.append = new.append
+            old.prepend = new.prepend
+            old.remove = []
+            return old
+        # Otherwise, we're simply appending to or removing from the old value,
+        # and these changes are propagated down to the old value.
+        if new.remove is not None:
+            old.remove = (old.remove or []) + new.remove
+            if old.value:
+                old.value = [e for e in old.value if e not in new.remove]
+            if old.prepend:
+                old.prepend = [e for e in old.prepend if e not in new.remove]
+            if old.append:
+                old.append = [e for e in old.append if e not in new.remove]
+        if new.append is not None:
+            old.append = (old.append or []) + new.append
+        if new.prepend is not None:
+            old.prepend = new.prepend + (old.prepend or [])
+        return old
+
+    def finalize(self) -> list[str | bool] | None:
+        empty = True
+        final = []
+        if self.value is not None:
+            empty = False
+            final = self.value
+        if self.append is not None:
+            empty = False
+            final = final + self.append
+        if self.prepend is not None:
+            empty = False
+            final = self.prepend + final
+        return None if (empty and self.clear) else final
+
+
+# Entries are of the following form
+# {
+#    "VAR_A": "value",
+#    "VAR_B": ["123", "456"],
+#    "VAR_C": false,
+#    "VAR_D": {
+#       "type": "STRING",
+#       "value": ["789", "xyz"],
+#    },
+#    "VAR_E": {
+#       "type": "FILEPATH",
+#       "value": "/usr/bin/bash",
+#    },
+#    "VAR_F": {
+#       "type": "FILEPATH",
+#       "append": ["/usr/bin/bash"],
+#    }
+# }
+
+
+class CMakeOptConfigOption(ConfigOption):
+    """
+    Dictionary of CMake options, with optional data type, ability to merge
+    or remove options, etc.
+    """
+
+    valid_keys = frozenset(
+        ("+", "-", "=", "append", "remove", "value", "prepend", "type", "strict")
+    )
+
+    def get_typename(self, md: bool = False) -> str:
+        return "dict (CMake)"
+
+    @staticmethod
+    def _check_type(a, a_path):
+        valid_types = (None, "STRING", "BOOL", "PATH", "FILEPATH")
+        if a not in valid_types:
+            msg = f"Unknown type '{a}' in {a_path}"
+            raise ConfigError(msg)
+
+    def _combine(self, a: CMakeOption, b: CMakeOption, a_path, b_path):
+        r = a.override(b)
+        r.datatype = CMakeOption._combine_types(a, b, b.strict, a_path, b_path)
+        return r
+
+    def override(self, old_value: ValueReference, new_value: ValueReference):
+        if new_value.values is None:
+            return None
+        if old_value.values is None:
+            old_value.values = {}
+        r = deepcopy(old_value.values)
+        for k, v in new_value.values.items():
+            if k not in r:
+                r[k] = deepcopy(v)
+            else:
+                r[k] = self._combine(
+                    a=r[k],
+                    b=v,
+                    a_path=old_value.value_path.join(k),
+                    b_path=new_value.value_path.join(k),
+                )
+        return r
+
+    def _verify_cmake_list(self, values: ValueReference):
+        if isinstance(values.values, list):
+            for v in values.values:
+                if not isinstance(v, str) and not isinstance(v, bool):
+                    msg = f"Type of values in list {values.value_path} should "
+                    msg += f"be str or bool, not {type(v)}"
+                    raise ConfigError(msg)
+        elif not isinstance(values.values, str) and not isinstance(values.values, bool):
+            msg = f"Type of values in {values.value_path} should be str or bool or a "
+            msg += f"list thereof, not {type(values.values)}"
+            raise ConfigError(msg)
+
+    def _verify_cmake_list_or_dict(self, values: ValueReference):
+        if isinstance(values.values, dict):
+            for k in values.values:
+                if not isinstance(k, str):
+                    msg = f"Type of keys in {values.value_path} should be str, "
+                    msg += f"not {type(k)}"
+                    raise ConfigError(msg)
+                self._verify_cmake_list(values.sub_ref(k))
+        else:
+            self._verify_cmake_list(values)
+
+    def _check_dict_keys(self, d, pth: ConfPath):
+        if not isinstance(d, dict):
+            return
+        invalid_keys = set(d) - self.valid_keys
+        if invalid_keys:
+            msg = f"Invalid keys in {pth}: {list(invalid_keys)}"
+            raise ConfigError(msg)
+        if "value" in d and "=" in d:
+            msg = f"Invalid keys in {pth}: "
+            msg += 'Cannot combine "value" and "="'
+            raise ConfigError(msg)
+        if "append" in d and "+" in d:
+            msg = f"Invalid keys in {pth}: "
+            msg += 'Cannot combine "append" and "+"'
+            raise ConfigError(msg)
+        if "remove" in d and "-" in d:
+            msg = f"Invalid keys in {pth}: "
+            msg += 'Cannot combine "remove" and "-"'
+            raise ConfigError(msg)
+        if "value" in d or "=" in d:
+            invalid_keys = {"+", "append", "-", "remove", "prepend"} & set(d)
+            if invalid_keys:
+                msg = f"Invalid keys in {pth}: "
+                msg += 'Cannot combine "value" or "=" with the '
+                msg += f"following keys: {list(invalid_keys)}"
+                raise ConfigError(msg)
+        if "type" in d:
+            self._check_type(d["type"], pth)
+
+    def verify(self, values: ValueReference):
+        """Checks the data types and keys of the values, and then converts
+        them to a dictionary of CMakeOptions."""
+        if values.values is None:
+            return None
+        if values.action not in (OverrideActionEnum.Append, OverrideActionEnum.Default):
+            msg = f"Option {values.value_path} of type {self.get_typename()} "
+            msg += f"does not support operation {values.action.value}"
+            raise ConfigError(msg)
+        if not isinstance(values.values, dict):
+            msg = f"Type of {values.value_path} should be {dict}, "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+        elif not all(isinstance(k, str) for k in values.values):
+            msg = f"Type of keys in {values.value_path} should be {str}"
+            raise ConfigError(msg)
+        for k in values.values:
+            self._verify_cmake_list_or_dict(values.sub_ref(k))
+
+        valdict: dict[str, CMakeOption] = {}
+        for k in values.values:
+            pth = values.value_path.join(k)
+            self._check_dict_keys(values.values[k], pth)
+            valdict[k] = CMakeOption.from_values(values.sub_ref(k))
+        return valdict
+
+    def finalize(self, values: ValueReference) -> dict[str, str] | None:
+        """Converts the internal dict of CMakeOptions back into a dict of string
+        that can be passed as CMake command-line arguments"""
+        if values.values is None:
+            return None
+
+        def convert(x):
+            assert isinstance(x, CMakeOption)
+            final = x.finalize()
+            if final is None:
+                return None
+            on_off = {True: "On", False: "Off"}
+            escape = lambda x: x.replace(";", "\\;")
+            to_str = lambda b: (escape(b) if isinstance(b, str) else on_off[b])
+            return ";".join(map(to_str, final))
+
+        def convert_key(k, x):
+            assert isinstance(x, CMakeOption)
+            return f"{k}:{x.datatype}" if x.datatype else k
+
+        options: dict[str, str] = {}
+        for k, v in values.values.items():
+            if v is not None:
+                str_v = convert(v)
+                if str_v is not None:
+                    options[convert_key(k, v)] = str_v
+        return options
diff --git a/src/py_build_cmake/config/options/config_option.py b/src/py_build_cmake/config/options/config_option.py
new file mode 100644
index 0000000..111856d
--- /dev/null
+++ b/src/py_build_cmake/config/options/config_option.py
@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+from copy import copy, deepcopy
+from difflib import get_close_matches
+from typing import Any, Iterable
+
+from ...common import ConfigError
+from .config_path import ConfPath
+from .default import DefaultValue, NoDefaultValue
+from .value_reference import OverrideActionEnum, ValueReference
+
+_MAGIC_CLEAR_VALUE = None
+
+
+class ConfigOption:
+    def __init__(
+        self,
+        name: str,
+        description: str = "",
+        example: str = "",
+        default: DefaultValue | None = None,
+        inherit_from: ConfPath | str | None = None,
+        create_if_inheritance_target_exists: bool = False,
+        sub_options: dict[str, ConfigOption] | None = None,
+    ) -> None:
+        if default is None:
+            default = NoDefaultValue()
+        if isinstance(inherit_from, str):
+            inherit_from = ConfPath.from_string(inherit_from)
+        if sub_options is None:
+            sub_options = {}
+        self.name = name
+        self.description = description
+        self.example = example
+        self.sub_options: dict[str, ConfigOption] = sub_options
+        self.inherits = inherit_from
+        self.default: DefaultValue = default
+        self.create_if_inheritance_target_exists = create_if_inheritance_target_exists
+
+    def insert(self, opt: ConfigOption):
+        assert opt.name not in self.sub_options
+        self.sub_options[opt.name] = opt
+        return self.sub_options[opt.name]
+
+    def insert_multiple(self, opts: Iterable[ConfigOption]):
+        for opt in opts:
+            self.insert(opt)
+        return self
+
+    def get_typename(self, md: bool = False) -> str | None:
+        return None
+
+    def iter_sub_options(
+        self, values: ValueReference
+    ) -> Iterable[tuple[str, ConfPath]]:
+        """Return the names of the sub-options of this config option, along with
+        the corresponding value path relative to the given value pth."""
+        for name in self.sub_options:
+            yield name, values.value_path.join(name)
+
+    def iter_set_sub_options(
+        self, values: ValueReference
+    ) -> Iterable[tuple[str, ValueReference]]:
+        """Return the names of the sub-options of this config option, along with
+        the corresponding value reference relative to the given value if set."""
+        for name in self.sub_options:
+            if values.is_value_set(name):
+                yield name, values.sub_ref(name)
+
+    def verify(self, values: ValueReference) -> Any:
+        if values.action == OverrideActionEnum.Clear:
+            return _MAGIC_CLEAR_VALUE
+        if values.action not in (OverrideActionEnum.Assign, OverrideActionEnum.Default):
+            msg = f"Option {values.value_path} does not support "
+            msg += f"operation {values.action.value}"
+            raise ConfigError(msg)
+        if not isinstance(values.values, dict):
+            msg = f"Type of {values.value_path} should be 'dict', "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+        unknown_keys = set(values.values) - set(self.sub_options)
+        msg = ""
+        for k in sorted(unknown_keys):
+            suggested = get_close_matches(k, self.sub_options, 3)
+            msg = f"Unknown option '{k}' in {values.value_path}. "
+            if suggested:
+                msg += f"Did you mean: {', '.join(suggested)}\n"
+        if msg:
+            raise ConfigError(msg[:-1])
+        return values.values
+
+    def finalize(self, values: ValueReference) -> Any:
+        if self.sub_options:
+            for k in list(values.values):
+                if values.values[k] == _MAGIC_CLEAR_VALUE:
+                    del values.values[k]
+        return values.values
+
+    def override(self, old_value: ValueReference, new_value: ValueReference) -> Any:
+        if new_value.values == _MAGIC_CLEAR_VALUE:
+            return _MAGIC_CLEAR_VALUE
+        return copy(old_value.values)
+
+
+class MultiConfigOption(ConfigOption):
+    def __init__(
+        self,
+        name: str,
+        description: str = "",
+        example: str = "",
+        default: DefaultValue | None = None,
+        inherit_from: ConfPath | str | None = None,
+        create_if_inheritance_target_exists: bool = False,
+    ) -> None:
+        super().__init__(
+            name=name,
+            description=description,
+            example=example,
+            default=default,
+            inherit_from=inherit_from,
+            create_if_inheritance_target_exists=create_if_inheritance_target_exists,
+        )
+
+    default_index = "*"
+
+    def iter_sub_options(
+        self, values: ValueReference
+    ) -> Iterable[tuple[str, ConfPath]]:
+        """Return the names of the sub-options of this config option, along with
+        the corresponding value path relative to the given value pth."""
+        if values.values is None:
+            return ()
+        for k in values.values:
+            val = values.sub_ref(k)
+            for name in self.sub_options:
+                yield name, val.value_path.join(name)
+
+    def iter_set_sub_options(
+        self, values: ValueReference
+    ) -> Iterable[tuple[str, ValueReference]]:
+        """Return the names of the sub-options of this config option, along with
+        the corresponding value reference relative to the given value if set."""
+        if values.values is None:
+            return ()
+        for k in values.values:
+            val = values.sub_ref(k)
+            for name in self.sub_options:
+                if val.is_value_set(name):
+                    yield name, val.sub_ref(name)
+
+    def _verify(self, values: ValueReference):
+        if values.values is None:
+            return
+        unknown_keys = set(values.values) - set(self.sub_options)
+        msg = ""
+        for k in sorted(unknown_keys):
+            suggested = get_close_matches(k, self.sub_options, 3)
+            msg = f"Unknown option '{k}' in {values.value_path}. "
+            if suggested:
+                msg += f"Did you mean: {', '.join(suggested)}\n"
+        if msg:
+            raise ConfigError(msg[:-1])
+
+    def _values_to_index_dict(self, values: ValueReference):
+        vals: dict[str, dict | None] = {}
+        for k in values.values:
+            try:
+                int(k)
+            except ValueError:
+                v0 = vals.setdefault(self.default_index, {})
+                assert v0 is not None
+                v0[k] = values.values[k]  # Copy any action as well
+                continue
+            vr = values.sub_ref(k)
+            if vr.action == OverrideActionEnum.Clear:
+                vals[k] = _MAGIC_CLEAR_VALUE
+            elif vr.action not in (
+                OverrideActionEnum.Assign,
+                OverrideActionEnum.Default,
+            ):
+                msg = f"Option {vr.value_path} does not support "
+                msg += f"operation {vr.action.value}"
+                raise ConfigError(msg)
+            else:
+                vals[k] = vr.values  # Do not copy action
+        return vals
+
+    def verify(self, values: ValueReference) -> Any:
+        if values.action == OverrideActionEnum.Clear:
+            return _MAGIC_CLEAR_VALUE
+        if values.action not in (OverrideActionEnum.Assign, OverrideActionEnum.Default):
+            msg = f"Option {values.value_path} does not support "
+            msg += f"operation {values.action.value}"
+            raise ConfigError(msg)
+        if not isinstance(values.values, dict):
+            msg = f"Type of {values.value_path} should be 'dict', "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+        if not all(isinstance(v, str) for v in values.values):
+            msg = f"Type of keys in {values.value_path} should be 'str'"
+            raise ConfigError(msg)
+        vals = self._values_to_index_dict(values)
+        for k, v in vals.items():
+            self._verify(ValueReference(values.value_path.join(k), v))
+        return vals
+
+    def finalize(self, values: ValueReference) -> Any:
+        from .config_reference import ConfigReference
+        from .override import ConfigOverrider
+
+        if values.is_value_set(self.default_index):
+            # Our own option as a "single" ConfigOption
+            opt = ConfigOption(
+                name=self.name,
+                description=self.description,
+                example=self.example,
+                default=self.default,
+                inherit_from=self.inherits,
+                create_if_inheritance_target_exists=self.create_if_inheritance_target_exists,
+                sub_options=self.sub_options,
+            )
+            # Override the non-default items by the default item.
+            ref = ConfigReference(ConfPath((self.name,)), opt)
+            for k in list(values.values):
+                if k == self.default_index:
+                    continue
+                if values.values[k] == _MAGIC_CLEAR_VALUE:
+                    del values.values[k]
+                    continue
+                super_value = deepcopy(values.sub_ref(self.default_index))
+                new_values = values.sub_ref(k)
+                for name in self.sub_options:
+                    if new_values.is_value_set(name):
+                        if super_value.is_value_set(name):
+                            new_value = ConfigOverrider(
+                                root=None,
+                                ref=ref.sub_ref(name),
+                                values=super_value.sub_ref(name),
+                                new_values=new_values.sub_ref(name),
+                            ).override()
+                        else:
+                            new_value = new_values.sub_ref(name).values
+                        super_value.set_value(name, new_value)
+                values.set_value(k, super_value.values)
+            if len(values.values) == 1:
+                values.values["0"] = values.values.pop(self.default_index)
+            else:
+                values.clear_value(self.default_index)
+
+        return values.values
+
+    def override(self, old_value: ValueReference, new_value: ValueReference) -> Any:
+        if new_value.values == _MAGIC_CLEAR_VALUE:
+            return _MAGIC_CLEAR_VALUE
+        # TODO: change implementation such that shallow copy is sufficient
+        r = deepcopy(old_value.values) or {}
+        for k, v in new_value.values.items():
+            if v == _MAGIC_CLEAR_VALUE:
+                r[k] = _MAGIC_CLEAR_VALUE
+            else:
+                r.setdefault(k, {})
+        return r
+
+
+class UncheckedConfigOption(ConfigOption):
+    def verify(self, values: ValueReference):
+        return values.values
diff --git a/src/py_build_cmake/config/options/config_path.py b/src/py_build_cmake/config/options/config_path.py
new file mode 100644
index 0000000..037c4e2
--- /dev/null
+++ b/src/py_build_cmake/config/options/config_path.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+
+class ConfPath:
+    def __init__(self, pth: tuple[str, ...] = ()):
+        self.pth = pth
+
+    @classmethod
+    def from_string(cls, str_pth: str):
+        return cls(tuple(filter(None, str_pth.split("/"))))
+
+    def __str__(self):
+        return "/".join(".." if x == "^" else x for x in self.pth)
+
+    def join(self, suffix: str | ConfPath):
+        if isinstance(suffix, str):
+            suffix = ConfPath((suffix,))
+        p1 = self.pth
+        p2 = suffix.pth
+        while p1 and p2 and p2[0] == "^":
+            p1 = p1[:-1]
+            p2 = p2[1:]
+        return ConfPath(p1 + p2)
+
+    def split(self) -> tuple[ConfPath, str]:
+        return ConfPath(self.pth[:-1]), self.pth[-1]
+
+    def split_front(self) -> tuple[str, ConfPath]:
+        return self.pth[0], ConfPath(self.pth[1:])
+
+    def relative_to(self, base: ConfPath):
+        """No special logic, simply drops the common prefix, raises an
+        assertion error if self does not start with base."""
+        n = len(base.pth)
+        assert base.pth == self.pth[:n]
+        return ConfPath(self.pth[n:])
+
+    def __bool__(self):
+        return bool(self.pth)
diff --git a/src/py_build_cmake/config/options/config_reference.py b/src/py_build_cmake/config/options/config_reference.py
new file mode 100644
index 0000000..1646fec
--- /dev/null
+++ b/src/py_build_cmake/config/options/config_reference.py
@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Iterable
+
+if TYPE_CHECKING:
+    from .config_option import ConfigOption
+from .config_path import ConfPath
+from .value_reference import ValueReference
+
+
+class ConfigReference:
+    def __init__(self, config_path: ConfPath, config: ConfigOption) -> None:
+        self.config_path = config_path
+        self.config = config
+
+    @property
+    def sub_options(self):
+        return self.config.sub_options
+
+    def iter_sub_options(
+        self, values: ValueReference
+    ) -> Iterable[tuple[ConfigReference, ConfPath]]:
+        """Return the sub-options of this config option, along with
+        the corresponding value paths relative to the given value."""
+        return ((self.sub_ref(k), v) for k, v in self.config.iter_sub_options(values))
+
+    def iter_set_sub_options(
+        self, values: ValueReference
+    ) -> Iterable[tuple[ConfigReference, ValueReference]]:
+        """Return the sub-options of this config option, along with the
+        corresponding value reference relative to the given value if set."""
+        return (
+            (self.sub_ref(k), v) for k, v in self.config.iter_set_sub_options(values)
+        )
+
+    def sub_ref(self, name: str | ConfPath) -> ConfigReference:
+        if isinstance(name, ConfPath) and len(name.pth) == 1:
+            name = name.pth[0]
+        if isinstance(name, str):
+            return ConfigReference(
+                config_path=self.config_path.join(name),
+                config=self.config.sub_options[name],
+            )
+        name, rem = name.split_front()
+        return self.sub_ref(name).sub_ref(rem)
+
+    def resolve_inheritance_single(self, root: ConfigReference) -> ConfigReference:
+        if self.config.inherits is None:
+            return self
+        # Find the option we inherit from and make sure it exists
+        parent_path = self.config.inherits
+        # TODO: should we support relative paths here?
+        # self.config_path.join(self.config.inherits)
+        try:
+            parent = root.sub_ref(parent_path)
+        except KeyError as e:
+            msg = f"Inheritance target {parent_path} is not a valid option"
+            msg += f" (in {self.config_path})"
+            raise ValueError(msg) from e
+        return parent
+
+    def resolve_inheritance(self, root: ConfigReference) -> ConfigReference:
+        if self.config.inherits is None:
+            return self
+        return self.resolve_inheritance_single(root).resolve_inheritance(root)
+
+    def __repr__(self) -> str:
+        return f"<ConfigReference to: '{self.config_path}'>"
diff --git a/src/py_build_cmake/config/options/default.py b/src/py_build_cmake/config/options/default.py
new file mode 100644
index 0000000..be14373
--- /dev/null
+++ b/src/py_build_cmake/config/options/default.py
@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from ...common import ConfigError
+from .config_path import ConfPath
+
+if TYPE_CHECKING:
+    from .config_reference import ConfigReference
+from .value_reference import ValueReference
+
+
+@dataclass
+class DefaultValueWrapper:
+    """To distinguish between None and DefaultValueWrapper(None)."""
+
+    value: Any
+
+
+class DefaultValue(ABC):
+    @abstractmethod
+    def get_default(
+        self,
+        defaulter: ConfigDefaulter,
+    ) -> DefaultValueWrapper | None: ...
+
+    @abstractmethod
+    def get_name(self) -> str: ...
+
+
+class ConfigDefaulter:
+    def __init__(
+        self,
+        root: ConfigReference,
+        root_values: ValueReference,
+        ref: ConfigReference | None = None,
+        value_path: ConfPath | None = None,
+    ) -> None:
+        if ref is None:
+            ref = root
+        if value_path is None:
+            value_path = ConfPath()
+        self.root = root
+        self.root_values = root_values
+        self.ref = ref
+        self.value_path = value_path
+
+    def get_value_or_default(self) -> DefaultValueWrapper | None:
+        try:
+            return DefaultValueWrapper(self.root_values.get_value(self.value_path))
+        except KeyError:
+            return self.ref.config.default.get_default(self)
+
+    def update_default(self):
+        value_set = True
+        if not self.root_values.is_value_set(self.value_path):
+            default = self.ref.config.default.get_default(self)
+            if default is not None:
+                default_value = ValueReference(self.value_path, default.value)
+                default_value.values = self.ref.config.verify(default_value)
+                value = self.ref.config.finalize(default_value)
+                self.root_values.set_value(self.value_path, value)
+            else:
+                value_set = False
+        if value_set:
+            value_ref = self.root_values.sub_ref(self.value_path)
+            for ref, value_path in self.ref.iter_sub_options(value_ref):
+                ConfigDefaulter(
+                    root=self.root,
+                    root_values=self.root_values,
+                    ref=ref.resolve_inheritance(self.root),
+                    value_path=value_path,
+                ).update_default()
+
+
+class DefaultValueValue(DefaultValue):
+    def __init__(self, value: Any) -> None:
+        self.value = value
+
+    def get_default(
+        self,
+        defaulter: ConfigDefaulter,
+    ) -> DefaultValueWrapper | None:
+        return DefaultValueWrapper(deepcopy(self.value))
+
+    def get_name(self) -> str:
+        if isinstance(self.value, bool):
+            return str(self.value).lower()
+        return repr(self.value)
+
+
+class NoDefaultValue(DefaultValue):
+    def __init__(self, name: str = "none"):
+        self.name = name
+
+    def get_default(
+        self,
+        defaulter: ConfigDefaulter,
+    ) -> DefaultValueWrapper | None:
+        return None
+
+    def get_name(self) -> str:
+        return self.name
+
+
+class MissingDefaultError(ConfigError):
+    """The user did not provide a required value."""
+
+
+class RequiredValue(DefaultValue):
+    def get_default(
+        self,
+        defaulter: ConfigDefaulter,
+    ) -> DefaultValueWrapper | None:
+        msg = f"{defaulter.value_path} requires a value"
+        raise MissingDefaultError(msg)
+
+    def get_name(self) -> str:
+        return "required"
+
+
+class RefDefaultValue(DefaultValue):
+    def __init__(self, path: ConfPath, relative: bool = False) -> None:
+        super().__init__()
+        self.path: ConfPath = path
+        self.relative = relative
+
+    def get_default(
+        self,
+        defaulter: ConfigDefaulter,
+    ) -> DefaultValueWrapper | None:
+        if self.relative:
+            rel_path = ConfPath(("^", *self.path.pth))
+            target_path = defaulter.ref.config_path.join(rel_path)
+            value_path = defaulter.value_path.join(rel_path)
+        else:
+            value_path = target_path = self.path
+        try:
+            target_opt = defaulter.root.sub_ref(target_path)
+        except KeyError as e:
+            msg = f"DefaultValue: reference to nonexisting option {target_path}"
+            msg += f" (in {defaulter.ref.config_path})"
+            raise ValueError(msg) from e
+        return ConfigDefaulter(
+            root=defaulter.root,
+            root_values=defaulter.root_values,
+            ref=target_opt.resolve_inheritance(defaulter.root),
+            value_path=value_path,
+        ).get_value_or_default()
+
+    def get_name(self) -> str:
+        r = str(self.path)
+        if not self.relative:
+            r = "/" + r
+        return r
diff --git a/src/py_build_cmake/config/options/dict.py b/src/py_build_cmake/config/options/dict.py
new file mode 100644
index 0000000..1369869
--- /dev/null
+++ b/src/py_build_cmake/config/options/dict.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from copy import deepcopy
+
+from ...common import ConfigError
+from .config_option import ConfigOption
+from .string import StringOption
+from .value_reference import OverrideActionEnum, ValueReference
+
+
+class DictOfStrConfigOption(ConfigOption):
+    def get_typename(self, md: bool = False) -> str:
+        return "dict"
+
+    def override(self, old_value: ValueReference, new_value: ValueReference):
+        if new_value.values is None:
+            return None
+        if old_value.values is None:
+            old_value.values = {}
+        r = deepcopy(old_value.values)
+        for k, v in new_value.values.items():
+            if k not in r:
+                r[k] = deepcopy(v)
+            else:
+                r[k] = r[k].override(v)
+        return r
+
+    def _verify_str(self, values: ValueReference):
+        if not isinstance(values.values, str):
+            msg = f"Type of values in {values.value_path} should be str, "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+
+    def verify(self, values: ValueReference):
+        if values.values is None:
+            return None
+        if values.action not in (OverrideActionEnum.Append, OverrideActionEnum.Default):
+            msg = f"Option {values.value_path} of type {self.get_typename()} "
+            msg += f"does not support operation {values.action.value}"
+            raise ConfigError(msg)
+
+        if not isinstance(values.values, dict):
+            msg = f"Type of {values.value_path} should be {dict}, "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+        elif not all(isinstance(el, str) for el in values.values):
+            msg = f"Type of keys in {values.value_path} should be {str}"
+            raise ConfigError(msg)
+        for k in values.values:
+            self._verify_str(values.sub_ref(k))
+
+        valdict: dict[str, StringOption] = {}
+        for k in values.values:
+            valdict[k] = StringOption.from_values(values.sub_ref(k))
+        return valdict
+
+    def finalize(self, values: ValueReference) -> dict[str, str] | None:
+        if values.values is None:
+            return None
+        options: dict[str, str] = {}
+        for k, v in values.values.items():
+            if v is not None:
+                assert isinstance(v, StringOption)
+                str_v = v.finalize()
+                if str_v is not None:
+                    options[k] = str_v
+        return options
diff --git a/src/py_build_cmake/config/options/dir_pattern.py b/src/py_build_cmake/config/options/dir_pattern.py
new file mode 100644
index 0000000..2ab2633
--- /dev/null
+++ b/src/py_build_cmake/config/options/dir_pattern.py
@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import os.path as osp
+import re
+from copy import copy
+from pathlib import PurePath
+
+from ...common import ConfigError
+from .config_path import ConfPath
+from .default import DefaultValue
+from .list import ListOfStrConfigOption, ListOption
+from .value_reference import ValueReference
+
+
+class DirPatternsConfigOption(ListOfStrConfigOption):
+    def __init__(
+        self,
+        name: str,
+        description: str = "",
+        example: str = "",
+        default: DefaultValue | None = None,
+        inherit_from: ConfPath | str | None = None,
+        create_if_inheritance_target_exists: bool = False,
+        convert_str_to_singleton=False,
+    ) -> None:
+        super().__init__(
+            name,
+            description,
+            example,
+            default,
+            inherit_from,
+            create_if_inheritance_target_exists,
+            convert_str_to_singleton,
+        )
+
+    def _verify_pattern_list(self, values: list[str], pth: ConfPath):
+        # Based on https://github.com/pypa/flit/blob/f7496a50debdfa393e39f8e51d328deabcd7ae7e/flit_core/flit_core/config.py#L215
+        pattern_list = copy(values)
+        # Windows filenames can't contain these (nor * or ?, but they are part of
+        # glob patterns) - https://stackoverflow.com/a/31976060/434217
+        bad_chars = re.compile(r'[\000-\037<>:"\\]')
+        for i, pattern in enumerate(pattern_list):
+            if bad_chars.search(pattern):
+                msg = f"Pattern '{pattern}' in {pth} contains bad characters (<>:\"\\ or control characters)"
+                raise ConfigError(msg)
+            # Normalize the path
+            normp = PurePath(osp.normpath(pattern))
+            # Make sure that the path is relative and inside of the project
+            if normp.is_absolute():
+                msg = f"Pattern '{pattern}' in {pth} should be relative"
+                raise ConfigError(msg)
+            if normp.parts[0] == "..":
+                msg = f"Pattern '{pattern}' in {pth} cannot refer to the parent directory (..)"
+                raise ConfigError(msg)
+            pattern_list[i] = str(normp)
+        return pattern_list
+
+    def verify(self, values: ValueReference):
+        v = super().verify(values)
+        assert isinstance(v, ListOption)
+        if v.value:
+            v.value = self._verify_pattern_list(v.value, values.value_path)
+        if v.append:
+            v.append = self._verify_pattern_list(v.append, values.value_path)
+        if v.prepend:
+            v.prepend = self._verify_pattern_list(v.prepend, values.value_path)
+        if v.remove:
+            v.remove = self._verify_pattern_list(v.remove, values.value_path)
+        return v
diff --git a/src/py_build_cmake/config/options/enum.py b/src/py_build_cmake/config/options/enum.py
new file mode 100644
index 0000000..359b165
--- /dev/null
+++ b/src/py_build_cmake/config/options/enum.py
@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from ...common import ConfigError
+from .config_option import ConfigOption
+from .config_path import ConfPath
+from .default import DefaultValue, NoDefaultValue
+from .value_reference import OverrideActionEnum, ValueReference
+
+
+class EnumConfigOption(ConfigOption):
+    def __init__(
+        self,
+        name: str,
+        description: str = "",
+        example: str = "",
+        default: DefaultValue | None = None,
+        inherit_from: ConfPath | str | None = None,
+        create_if_inheritance_target_exists: bool = False,
+        options: list[str] | None = None,
+    ) -> None:
+        if default is None:
+            default = NoDefaultValue()
+        if options is None:
+            options = []
+        super().__init__(
+            name,
+            description,
+            example,
+            default,
+            inherit_from,
+            create_if_inheritance_target_exists,
+        )
+        self.options = options
+
+    def get_typename(self, md: bool = False):
+        if md:
+            return "`'" + "'` \\| `'".join(self.options) + "'`"
+        else:
+            return "'" + "' | '".join(self.options) + "'"
+
+    def override(self, old_value: ValueReference, new_value: ValueReference):
+        return new_value.values
+
+    def verify(self, values: ValueReference):
+        if values.values is None:
+            return None
+        if values.action not in (OverrideActionEnum.Assign, OverrideActionEnum.Default):
+            msg = f"Enumeration option {values.value_path} "
+            msg += f"does not support operation {values.action.value}"
+            raise ConfigError(msg)
+        elif not isinstance(values.values, str):
+            msg = f"Type of {values.value_path} should be {str}, "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+        if values.values not in self.options:
+            msg = f"Value of {values.value_path} should be one of "
+            msg += "'" + "', '".join(self.options) + "'"
+            raise ConfigError(msg)
+        return values.values
diff --git a/src/py_build_cmake/config/options/finalize.py b/src/py_build_cmake/config/options/finalize.py
new file mode 100644
index 0000000..0eaff45
--- /dev/null
+++ b/src/py_build_cmake/config/options/finalize.py
@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from copy import copy
+
+from .config_reference import ConfigReference
+from .value_reference import ValueReference
+
+
+class ConfigFinalizer:
+    def __init__(
+        self, root: ConfigReference, ref: ConfigReference, values: ValueReference
+    ) -> None:
+        self.root = root
+        self.ref = ref
+        self.values = values
+
+    def finalize(self):
+        final_values = ValueReference(
+            self.values.value_path,
+            self.ref.config.finalize(copy(self.values)),
+        )
+        for ref, val_ref in self.ref.iter_set_sub_options(final_values):
+            final_val = ConfigFinalizer(
+                root=self.root,
+                ref=ref.resolve_inheritance(self.root),
+                values=val_ref,
+            ).finalize()
+            rel = val_ref.value_path.relative_to(final_values.value_path)
+            if final_val is None:
+                final_values.clear_value(rel)
+            else:
+                final_values.set_value(rel, final_val)
+        return final_values.values
diff --git a/src/py_build_cmake/config/options/inherit.py b/src/py_build_cmake/config/options/inherit.py
new file mode 100644
index 0000000..02f9f92
--- /dev/null
+++ b/src/py_build_cmake/config/options/inherit.py
@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from .config_path import ConfPath
+from .config_reference import ConfigReference
+from .override import ConfigOverrider
+from .value_reference import ValueReference
+
+
+class ConfigInheritor:
+    def __init__(
+        self,
+        root: ConfigReference,
+        root_values: ValueReference,
+        ref: ConfigReference | None = None,
+        value_path: ConfPath | None = None,
+        done: set[tuple[str, ...]] | None = None,
+    ) -> None:
+        if ref is None:
+            ref = root
+        if value_path is None:
+            value_path = ConfPath()
+        if done is None:
+            done = set()
+        self.root = root
+        self.root_values = root_values
+        self.ref = ref
+        self.value_path = value_path
+        self.done = done
+
+    def _inherit_self(self):
+        # Check if this option inherits from another option
+        inherits = self.ref.config.inherits
+        if inherits is None:
+            return
+        # Only carry out the inheritance once
+        if self.value_path.pth in self.done:
+            return
+        self.done.add(self.value_path.pth)
+        # Find the option we inherit from
+        super = self.ref.resolve_inheritance_single(self.root)
+        # If the option we're inheriting from does not have its value set,
+        # don't do anything.
+        try:
+            super_value = self.root_values.sub_ref(super.config_path)
+        except KeyError:
+            return
+        # If our option does not have its value set, create this value and
+        # all its parents.
+        if not self._create_parent_values():
+            return
+
+        # If our super option inherits from other options, carry out that
+        # inheritance first.
+        ConfigInheritor(
+            root=self.root,
+            root_values=self.root_values,
+            ref=super,
+            value_path=super.config_path,
+            done=self.done,
+        )._inherit_self()
+        # Note that we only detect direct inheritance, inheriting from a
+        # subtree that is part of an inherited tree is not supported (and
+        # and unnecessary for the current schema)
+
+        # Create a copy of the values of our super option and override them
+        # with our own values
+        new_values = self.root_values.sub_ref(self.value_path)
+        assert new_values is not None
+        real_config = super.resolve_inheritance(self.root)
+        inherited_values = ConfigOverrider(
+            root=self.root,
+            ref=real_config,
+            values=super_value,
+            new_values=new_values,
+        ).override()
+        self.root_values.set_value(self.value_path, inherited_values)
+
+    def _create_parent_values(self):
+        """
+        Loop over all parent options of path in the root and default-initialize
+        their values to an empty dict if the option's
+        create_if_inheritance_target_exists member is set to True.
+        """
+        sub, val = self.root, self.root_values
+        for s in self.value_path.pth:
+            sub = sub.sub_ref(s)
+            try:
+                val = val and val.sub_ref(s)
+            except KeyError:
+                if not sub.config.create_if_inheritance_target_exists:
+                    return False
+                val = None
+        val = self.root_values
+        for s in self.value_path.pth:
+            val.values.setdefault(s, {})
+            val = val.sub_ref(s)
+            assert val is not None
+        return True
+
+    def inherit(self):
+        self._inherit_self()
+        if self.root_values.is_value_set(self.value_path):
+            values = self.root_values.sub_ref(self.value_path)
+        else:
+            values = ValueReference(self.value_path, None)
+        for ref, val_path in self.ref.iter_sub_options(values):
+            ConfigInheritor(
+                root=self.root,
+                root_values=self.root_values,
+                ref=ref,
+                value_path=val_path,
+                done=self.done,
+            ).inherit()
diff --git a/src/py_build_cmake/config/options/int.py b/src/py_build_cmake/config/options/int.py
new file mode 100644
index 0000000..acedc53
--- /dev/null
+++ b/src/py_build_cmake/config/options/int.py
@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from ...common import ConfigError
+from .config_option import ConfigOption
+from .value_reference import OverrideActionEnum, ValueReference
+
+
+class IntConfigOption(ConfigOption):
+    def get_typename(self, md: bool = False):
+        return "int"
+
+    def override(self, old_value: ValueReference, new_value: ValueReference):
+        return new_value.values
+
+    def verify(self, values: ValueReference):
+        if values.values is None:
+            return None
+        if values.action not in (OverrideActionEnum.Assign, OverrideActionEnum.Default):
+            msg = f"Option {values.value_path} of type {self.get_typename()} "
+            msg += f"does not support operation {values.action.value}"
+            raise ConfigError(msg)
+        elif not isinstance(values.values, int):
+            msg = f"Type of {values.value_path} should be {int}, "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+        return values.values
diff --git a/src/py_build_cmake/config/options/list.py b/src/py_build_cmake/config/options/list.py
new file mode 100644
index 0000000..d482fba
--- /dev/null
+++ b/src/py_build_cmake/config/options/list.py
@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+from copy import copy
+from dataclasses import dataclass
+
+from ...common import ConfigError
+from .config_option import ConfigOption
+from .config_path import ConfPath
+from .default import DefaultValue
+from .string import StringOption
+from .value_reference import OverrideActionEnum, ValueReference
+
+
+@dataclass
+class ListOption:
+    clear: bool = False
+    value: list[str] | None = None
+    append: list[str] | None = None
+    prepend: list[str] | None = None
+    remove: list[str] | None = None
+
+    @classmethod
+    def from_values(cls, values: ValueReference, append_by_default: bool):
+        val = values.values
+        if values.action == OverrideActionEnum.Clear:
+            assert val is None
+            return cls(clear=True)
+        if not isinstance(val, list) or not all(isinstance(v, str) for v in val):
+            msg = f"Invalid type {type(val)}"
+            raise AssertionError(msg)
+        if values.action == OverrideActionEnum.Default:
+            return cls(append=val) if append_by_default else cls(value=val)
+        if values.action == OverrideActionEnum.Assign:
+            return cls(value=val)
+        if values.action == OverrideActionEnum.Remove:
+            return cls(remove=val)
+        if values.action == OverrideActionEnum.Append:
+            return cls(append=val)
+        if values.action == OverrideActionEnum.Prepend:
+            return cls(prepend=val)
+        msg = f"Invalid action {values.action}"
+        raise AssertionError(msg)
+
+    def override(self, new: ListOption):
+        # Clearing always propagates
+        if new.clear:
+            return copy(new)
+        old = copy(self)
+        # If we're overriding with a value, the old value is not used
+        if new.value is not None:
+            old.value = new.value
+            old.append = new.append
+            old.prepend = new.prepend
+            old.remove = []
+            return old
+        # Otherwise, we're simply appending to or removing from the old value,
+        # and these changes are propagated down to the old value.
+        if new.remove is not None:
+            old.remove = (old.remove or []) + new.remove
+            if old.value:
+                old.value = [e for e in old.value if e not in new.remove]
+            if old.prepend:
+                old.prepend = [e for e in old.prepend if e not in new.remove]
+            if old.append:
+                old.append = [e for e in old.append if e not in new.remove]
+        if new.append is not None:
+            old.append = (old.append or []) + new.append
+        if new.prepend is not None:
+            old.prepend = new.prepend + (old.prepend or [])
+        return old
+
+    def finalize(self) -> list[str] | None:
+        empty = True
+        final = []
+        if self.value is not None:
+            empty = False
+            final = self.value
+        if self.append is not None:
+            empty = False
+            final = final + self.append
+        if self.prepend is not None:
+            empty = False
+            final = self.prepend + final
+        return None if (empty and self.clear) else final
+
+
+class ListOfStrConfigOption(ConfigOption):
+    def __init__(
+        self,
+        name: str,
+        description: str = "",
+        example: str = "",
+        default: DefaultValue | None = None,
+        inherit_from: ConfPath | str | None = None,
+        create_if_inheritance_target_exists: bool = False,
+        convert_str_to_singleton=False,
+        append_by_default=False,
+    ) -> None:
+        super().__init__(
+            name,
+            description,
+            example,
+            default,
+            inherit_from,
+            create_if_inheritance_target_exists,
+        )
+        self.convert_str_to_singleton = convert_str_to_singleton
+        self.append_by_default = append_by_default
+
+    valid_keys = frozenset(("+", "-", "=", "append", "remove", "value", "prepend"))
+
+    def get_typename(self, md: bool = False):
+        return "list+" if self.append_by_default else "list"
+
+    def override(self, old_value: ValueReference, new_value: ValueReference):
+        new, old = new_value.values, copy(old_value.values)
+        if old is None:  # No previous value
+            old = ListOption()
+        assert isinstance(new, ListOption)
+        assert isinstance(old, ListOption)
+        return old.override(new)
+
+    def _check_dict_keys(self, d: dict, pth: ConfPath):
+        invalid_keys = set(d) - self.valid_keys
+        if invalid_keys:
+            msg = f"Invalid keys in {pth}: {list(invalid_keys)}"
+            raise ConfigError(msg)
+        if "value" in d and "=" in d:
+            msg = f"Invalid keys in {pth}: "
+            msg += 'Cannot combine "value" and "="'
+            raise ConfigError(msg)
+        if "append" in d and "+" in d:
+            msg = f"Invalid keys in {pth}: "
+            msg += 'Cannot combine "append" and "+"'
+            raise ConfigError(msg)
+        if "remove" in d and "-" in d:
+            msg = f"Invalid keys in {pth}: "
+            msg += 'Cannot combine "remove" and "-"'
+            raise ConfigError(msg)
+        if "value" in d or "=" in d:
+            invalid_keys = {"+", "append", "-", "remove", "prepend"} & set(d)
+            if invalid_keys:
+                msg = f"Invalid keys in {pth}: "
+                msg += 'Cannot combine "value" or "=" with the '
+                msg += f"following keys: {list(invalid_keys)}"
+                raise ConfigError(msg)
+
+    def _verify_dict(self, values: ValueReference) -> ListOption:
+        if values.action not in (OverrideActionEnum.Assign, OverrideActionEnum.Default):
+            msg = f"Type of {values.value_path} should be {list}, "
+            msg += f"not {dict}"
+            raise ConfigError(msg)
+        x = values.values
+        self._check_dict_keys(x, values.value_path)
+        opt = ListOption()
+        if "=" in x:
+            x["value"] = x.pop("=")
+        if "+" in x:
+            x["append"] = x.pop("+")
+        if "-" in x:
+            x["remove"] = x.pop("-")
+        for k in ("value", "append", "remove", "prepend"):
+            if k not in x:
+                continue
+            v = x.pop(k)
+            pthname = f"{values.value_path}[{k}]"
+            if not isinstance(v, list):
+                msg = f"Type of {pthname} should be {list}, not {type(v)}"
+                raise ConfigError(msg)
+            if not all(isinstance(el, str) for el in v):
+                msg = f"Type of elements in {pthname} should be {str}"
+                raise ConfigError(msg)
+            setattr(opt, k, v)
+        assert not x
+        return opt
+
+    def verify(self, values: ValueReference):
+        if isinstance(values.values, dict):
+            return self._verify_dict(values)
+        elif not isinstance(values.values, list):
+            if self.convert_str_to_singleton and isinstance(values.values, str):
+                values.values = values.values = [values.values]
+            elif values.values is None and values.action == OverrideActionEnum.Clear:
+                pass
+            else:
+                msg = f"Type of {values.value_path} should be {list}, "
+                msg += f"not {type(values.values)}"
+                raise ConfigError(msg)
+        elif not all(isinstance(el, str) for el in values.values):
+            msg = f"Type of elements in {values.value_path} should be {str}"
+            raise ConfigError(msg)
+        path_actions = (OverrideActionEnum.AppendPath, OverrideActionEnum.PrependPath)
+        if values.action in path_actions:
+            msg = f"Option {values.value_path} of type {self.get_typename()} "
+            msg += f"does not support operation {values.action.value}"
+            raise ConfigError(msg)
+        return ListOption.from_values(values, self.append_by_default)
+
+    def finalize(self, values: ValueReference):
+        val = values.values
+        if isinstance(val, list):
+            return val
+        # We allow lists inheriting from strings
+        if self.convert_str_to_singleton and isinstance(val, StringOption):
+            val = val.finalize()
+            return None if val is None else [val]
+        # The following is the main case
+        assert isinstance(val, ListOption)
+        return val.finalize()
diff --git a/src/py_build_cmake/config/options/override.py b/src/py_build_cmake/config/options/override.py
new file mode 100644
index 0000000..91ba796
--- /dev/null
+++ b/src/py_build_cmake/config/options/override.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .config_path import ConfPath
+from .config_reference import ConfigReference
+from .value_reference import ValueReference
+
+
+class ConfigOverrider:
+    def __init__(
+        self,
+        root: ConfigReference | None,
+        ref: ConfigReference,
+        values: ValueReference,
+        new_values: ValueReference,
+    ) -> None:
+        self.ref = ref
+        self.root = root
+        self.values = values
+        self.new_values = new_values
+
+    def override(self):
+        # Override our own value
+        overridden_values = ValueReference(
+            self.values.value_path,
+            self.ref.config.override(self.values, self.new_values),
+        )
+        # If we have sub-options, override those
+        for ref, new_val in self.ref.iter_set_sub_options(self.new_values):
+            if self.root is not None:
+                ref = ref.resolve_inheritance(self.root)  # noqa: PLW2901
+            rel = new_val.value_path.relative_to(self.new_values.value_path)
+            # Create default parent options if necessary (for MultiConfigOption)
+            if not self._create_default_parents(overridden_values, ref, rel):
+                continue
+            # Replace the old value by the override
+            old_val = overridden_values.sub_ref(rel)
+            overridden_values.set_value(
+                rel,
+                ConfigOverrider(
+                    root=self.root,
+                    ref=ref,
+                    values=old_val,
+                    new_values=new_val,
+                ).override(),
+            )
+        return overridden_values.values
+
+    def _create_default_parents(
+        self, overridden_values: ValueReference, ref: ConfigReference, rel: ConfPath
+    ):
+        fst, rem = rel.split_front()
+        relp = ConfPath((fst,))
+        for p in rem.pth:
+            if not overridden_values.set_value_default(relp, {}):
+                return False
+            relp = relp.join(p)
+        default: Any = {} if ref.sub_options else None
+        return overridden_values.set_value_default(relp, default)
diff --git a/src/py_build_cmake/config/options/path.py b/src/py_build_cmake/config/options/path.py
new file mode 100644
index 0000000..b123903
--- /dev/null
+++ b/src/py_build_cmake/config/options/path.py
@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+
+from ...common import ConfigError
+from .config_option import ConfigOption
+from .config_path import ConfPath
+from .default import DefaultValue
+from .value_reference import OverrideActionEnum, ValueReference
+
+
+@dataclass
+class RelativeToCurrentConfig:
+    project_path: Path | PurePosixPath
+    description: str = "current configuration file"
+
+
+@dataclass
+class RelativeToProject:
+    project_path: Path | PurePosixPath
+    description: str = "project directory"
+
+
+class PathConfigOption(ConfigOption):
+    def __init__(
+        self,
+        name: str,
+        description: str = "",
+        example: str = "",
+        default: DefaultValue | None = None,
+        inherit_from: ConfPath | str | None = None,
+        create_if_inheritance_target_exists: bool = False,
+        must_exist: bool = True,
+        expected_contents: list[str] | None = None,
+        base_path: RelativeToProject | RelativeToCurrentConfig | None = None,
+        allow_abs: bool = False,
+        is_folder: bool = True,
+    ):
+        if expected_contents is None:
+            expected_contents = []
+        super().__init__(
+            name,
+            description,
+            example,
+            default,
+            inherit_from,
+            create_if_inheritance_target_exists,
+        )
+        self.must_exist = must_exist or bool(expected_contents)
+        self.expected_contents = expected_contents
+        self.base_path = base_path
+        self.allow_abs = allow_abs
+        self.is_folder = is_folder
+        if self.base_path:
+            assert self.base_path.project_path.is_absolute()
+
+    def get_typename(self, md: bool = False):
+        return "path" if self.is_folder else "filepath"
+
+    def override(self, old_value, new_value):
+        return new_value.values
+
+    def _verify_string(self, values: ValueReference):
+        if values.values is None:
+            return None
+        if values.action not in (OverrideActionEnum.Assign, OverrideActionEnum.Default):
+            msg = f"Option {values.value_path} of type {self.get_typename()} "
+            msg += f"does not support operation {values.action.value}"
+            raise ConfigError(msg)
+        elif not isinstance(values.values, str):
+            msg = f"Type of {values.value_path} should be {str}, "
+            msg += f"not {type(values.values)}"
+            raise ConfigError(msg)
+        return values.values
+
+    def check_path(self, values: ValueReference):
+        assert isinstance(values.values, str)
+        path: Path | PurePosixPath = Path(values.values)
+        # Absolute or relative path?
+        if path.is_absolute():
+            # Absolute path
+            if not self.allow_abs:
+                msg = f'{values.value_path}: "{path!s}" must be a relative path'
+                raise ConfigError(msg)
+        # Relative path
+        elif isinstance(self.base_path, RelativeToCurrentConfig):
+            # value_path[0] is relative for files inside of the project,
+            # otherwise it is absolute
+            path = Path(PurePosixPath(values.value_path.pth[0]).parent / path)
+            if not path.is_absolute():
+                path = self.base_path.project_path / path
+        elif isinstance(self.base_path, RelativeToProject):
+            path = self.base_path.project_path / path
+        else:
+            msg = "Invalid relative path type"
+            raise AssertionError(msg)
+        assert path.is_absolute(), f"Failed to make path absolute: {path!s}"
+        # Does the path exist?
+        if self.must_exist:
+            path = Path(path)
+            if not path.exists():
+                msg = f'{values.value_path}: "{path!s}" does not exist'
+                raise ConfigError(msg)
+            if self.is_folder != path.is_dir():
+                type_ = "directory" if self.is_folder else "file"
+                msg = f'{values.value_path}: "{path!s}" should be a {type_}'
+                raise ConfigError(msg)
+            # Are any of the required contents missing?
+            missing = [
+                sub for sub in self.expected_contents if not (path / Path(sub)).exists()
+            ]
+            if missing:
+                missingstr = '", "'.join(missing)
+                msg = f'{values.value_path}: "{path!s}" does not contain the following required files or folders: "{missingstr}"'
+                raise ConfigError(msg)
+        return path.resolve() if isinstance(path, Path) else path
+
+    def verify(self, values: ValueReference):
+        values.values = self._verify_string(values)
+        if not values.values:
+            return values.values
+        return self.check_path(values)
diff --git a/src/py_build_cmake/config/options/pyproject_options.py b/src/py_build_cmake/config/options/pyproject_options.py
new file mode 100644
index 0000000..841d867
--- /dev/null
+++ b/src/py_build_cmake/config/options/pyproject_options.py
@@ -0,0 +1,610 @@
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+
+from ...common import CMAKE_MINIMUM_REQUIRED
+from .bool import BoolConfigOption
+from .cmake_opt import CMakeOptConfigOption
+from .config_option import ConfigOption, MultiConfigOption, UncheckedConfigOption
+from .config_path import ConfPath
+from .default import DefaultValueValue, NoDefaultValue, RefDefaultValue, RequiredValue
+from .dict import DictOfStrConfigOption
+from .dir_pattern import DirPatternsConfigOption
+from .enum import EnumConfigOption
+from .int import IntConfigOption
+from .list import ListOfStrConfigOption
+from .path import PathConfigOption, RelativeToCurrentConfig, RelativeToProject
+from .string import StringConfigOption
+
+
+def get_tool_pbc_path():
+    return ConfPath.from_string("pyproject.toml/tool/py-build-cmake")
+
+
+def get_component_path():
+    return ConfPath.from_string("pyproject.toml/tool/py-build-cmake/component")
+
+
+def get_cross_path():
+    return ConfPath.from_string("pyproject.toml/tool/py-build-cmake/cross")
+
+
+def get_options(project_path: Path | PurePosixPath, *, test: bool = False):
+    root = ConfigOption("root")
+    pyproject = root.insert(UncheckedConfigOption("pyproject.toml"))
+    project = pyproject.insert(UncheckedConfigOption("project"))
+    project.insert(UncheckedConfigOption("name", default=RequiredValue()))
+    name_pth = ConfPath.from_string("pyproject.toml/project/name")
+    tool = pyproject.insert(
+        UncheckedConfigOption("tool",
+                              default=DefaultValueValue({}),
+                              create_if_inheritance_target_exists=True,
+        ))  # fmt: skip
+    pbc = tool.insert(
+        ConfigOption("py-build-cmake",
+                     default=DefaultValueValue({}),
+                     create_if_inheritance_target_exists=True,
+        ))  # fmt: skip
+    # TODO: we should warn if these are present in the main config
+    pbc.insert_multiple([
+        UncheckedConfigOption("main_project"),
+        UncheckedConfigOption("component"),
+    ])  # fmt: skip
+
+    # [tool.py-build-cmake.module]
+    module = pbc.insert(
+        ConfigOption("module",
+                     "Defines the import name of the module or package, and "
+                     "the directory where it can be found.",
+                     default=DefaultValueValue({}),
+        ))  # fmt: skip
+    module.insert_multiple([
+        StringConfigOption("name",
+                           "Import name in Python (can be different from the "
+                           "name on PyPI, which is defined in the [project] "
+                           "section).",
+                        default=RefDefaultValue(name_pth)),
+        PathConfigOption("directory",
+                         "Directory containing the Python module/package.",
+                         default=DefaultValueValue("."),
+                         base_path=RelativeToProject(project_path),
+                         must_exist=not test),
+        BoolConfigOption("namespace",
+                         "Set to true for PEP 420 namespace packages.",
+                         default=DefaultValueValue(False)),
+        EnumConfigOption("generated",
+                         "Do not try to locate the main module in the source "
+                         "directory, but assume that it is generated by CMake. "
+                         "Dynamic metadata cannot be used when set.",
+                         options=["module", "package"]),
+    ])  # fmt: skip
+
+    # [tool.py-build-cmake.editable]
+    editable = pbc.insert(
+        ConfigOption("editable",
+                     "Defines how to perform an editable install (PEP 660). "
+                     "See https://tttapa.github.io/py-build-cmake/"
+                     "Editable-install.html for more information.",
+                     default=DefaultValueValue({}),
+        ))  # fmt: skip
+    editable_pth = ConfPath.from_string("pyproject.toml/tool/py-build-cmake/editable")
+    editable.insert_multiple([
+        EnumConfigOption("mode",
+                         "Mechanism to use for editable installations. "
+                         "Either write a wrapper __init__.py file, install an "
+                         "import hook, or install symlinks to the original "
+                         "files.",
+                         default=DefaultValueValue("symlink"),
+                         options=["wrapper", "hook", "symlink"]),
+        BoolConfigOption("build_hook",
+                         "Automatically re-build any changed files and C "
+                         "extension modules when the package is first "
+                         "imported by Python. It is recommended to use a fast "
+                         "generator like Ninja. Currently, the only "
+                         "mode that supports build hooks is `symlink`.",
+                         default=DefaultValueValue(False)),
+    ])  # fmt: skip
+
+    # [tool.py-build-cmake.sdist]
+    sdist = pbc.insert(
+        ConfigOption("sdist",
+                     "Specifies the files that should be included in the "
+                     "source distribution for this package.",
+                     default=DefaultValueValue({}),
+                     create_if_inheritance_target_exists=True,
+        ))  # fmt: skip
+    sdist_pth = ConfPath.from_string("pyproject.toml/tool/py-build-cmake/sdist")
+    sdist.insert_multiple([
+        DirPatternsConfigOption("include",
+                                "Files and folders to include in the source "
+                                "distribution. May include the '*' wildcard "
+                                "(but not '**' for recursive patterns).",
+                                default=DefaultValueValue([])),
+        DirPatternsConfigOption("exclude",
+                                "Files and folders to exclude from the source "
+                                "distribution. May include the '*' wildcard "
+                                "(but not '**' for recursive patterns).",
+                                default=DefaultValueValue([])),
+    ])  # fmt: skip
+
+    # [tool.py-build-cmake.cmake]
+    cmake = pbc.insert(
+        MultiConfigOption("cmake",
+                     "Defines how to build the project to package. If omitted, "
+                     "py-build-cmake will produce a pure Python package.",
+        ))  # fmt: skip
+    cmake_pth = ConfPath.from_string("pyproject.toml/tool/py-build-cmake/cmake")
+    cmake.insert_multiple([
+        StringConfigOption("minimum_version",
+                           "Minimum required CMake version. Used for policies "
+                           "in the automatically generated CMake cache pre-"
+                           "load files. If this version is not available in "
+                           "the system PATH, it will be installed "
+                           "automatically as a build dependency (using Pip).",
+                           "minimum_version = \"3.18\"",
+                           default=DefaultValueValue(CMAKE_MINIMUM_REQUIRED)),
+        StringConfigOption("build_type",
+                           "Build type passed to the configuration step, as "
+                           "`-DCMAKE_BUILD_TYPE=<?>`.",
+                           "build_type = \"RelWithDebInfo\""),
+        ListOfStrConfigOption("config",
+                              "Configuration type passed to the build step, "
+                              "as `--config <?>`. You can specify either a "
+                              "single string, or a list of strings. If a "
+                              "multi-config generator is used, all "
+                              "configurations in this list will be built.",
+                              "config = [\"Debug\", \"Release\"]",
+                              default=RefDefaultValue(
+                                  ConfPath.from_string("build_type"),
+                                  relative=True,
+                              ),
+                              convert_str_to_singleton=True),
+        StringConfigOption("preset",
+                           "CMake preset to use for configuration. Passed as "
+                           "`--preset <?>` during the configuration phase."),
+        ListOfStrConfigOption('build_presets',
+                              "CMake presets to use for building. Passed as "
+                              "`--preset <?>` during the build phase, once "
+                              "for each preset.",
+                              default=None,
+                              convert_str_to_singleton=True),
+        StringConfigOption("generator",
+                           "CMake generator to use, passed to the "
+                           "configuration step, as "
+                           "`-G <?>`. If Ninja is used, and if it is not "
+                           "available in the system PATH, it will be installed "
+                           "automatically as a build dependency.",
+                           "generator = \"Ninja Multi-Config\""),
+        PathConfigOption("source_path",
+                         "Folder containing CMakeLists.txt.",
+                         default=DefaultValueValue("."),
+                         expected_contents=[] if test else ["CMakeLists.txt"],
+                         base_path=RelativeToProject(project_path),
+                         must_exist=not test),
+        PathConfigOption("build_path",
+                         "CMake build and cache folder. The placeholder "
+                         "`{build_config}` can be used to insert the name of "
+                         "the Python version and ABI, operating system, and "
+                         "architecture. This ensures that separate build "
+                         "directories are used for different host systems and "
+                         "Python versions/implementations.",
+                         default=DefaultValueValue(".py-build-cmake_cache/{build_config}"),
+                         allow_abs=True,
+                         base_path=RelativeToProject(project_path),
+                         must_exist=False),
+        CMakeOptConfigOption("options",
+                             "Extra options passed to the configuration step, "
+                             "as `-D<option>=<value>`.",
+                             "options = {\"WITH_FEATURE_X\" = true}",
+                             default=DefaultValueValue({})),
+        ListOfStrConfigOption("args",
+                              "Extra arguments passed to the configuration "
+                              "step.",
+                              "args = [\"--debug-find\", \"-Wdev\"]",
+                              default=DefaultValueValue([]),
+                              append_by_default=True),
+        BoolConfigOption("find_python",
+                         "Specify hints for CMake's FindPython module.",
+                         "find_python = false",
+                         default=DefaultValueValue(True)),
+        BoolConfigOption("find_python3",
+                         "Specify hints for CMake's FindPython3 module.",
+                         "find_python3 = false",
+                         default=DefaultValueValue(True)),
+        ListOfStrConfigOption("build_args",
+                              "Extra arguments passed to the build step.",
+                              "build_args = [\"-j\", \"--target\", \"foo\"]",
+                              default=DefaultValueValue([]),
+                              append_by_default=True),
+        ListOfStrConfigOption("build_tool_args",
+                              "Extra arguments passed to the build tool in the "
+                              "build step (e.g. to Make or Ninja).",
+                              "build_tool_args = "
+                              "[\"--verbose\", \"-d\", \"explain\"]",
+                              default=DefaultValueValue([]),
+                              append_by_default=True),
+        ListOfStrConfigOption("install_config",
+                              "Configuration types passed to the "
+                              "install step, as `--config <?>`. You can "
+                              "specify either a single string, or a list of "
+                              "strings. If a multi-config generator is used, "
+                              "all configurations in this list will be "
+                              "included in the package.",
+                              "install_config = [\"Debug\", \"Release\"]",
+                              default=RefDefaultValue(
+                                  ConfPath.from_string("config"),
+                                  relative=True,
+                              ),
+                              convert_str_to_singleton=True),
+        ListOfStrConfigOption("install_args",
+                              "Extra arguments passed to the install step.",
+                              "install_args = [\"--strip\"]",
+                              default=DefaultValueValue([]),
+                              append_by_default=True),
+        ListOfStrConfigOption("install_components",
+                              "List of components to install, the install step "
+                              "is executed once for each component, with the "
+                              "option `--component <?>`.\n"
+                              "Use an empty string to specify the default "
+                              "component.",
+                              default=DefaultValueValue([""])),
+        DictOfStrConfigOption("env",
+                              "Environment variables to set when running "
+                              "CMake. Supports variable expansion using "
+                              "`${VAR}` (but not `$VAR`).",
+                              "env = { \"CMAKE_PREFIX_PATH\" "
+                              "= \"${HOME}/.local\" }",
+                              default=DefaultValueValue({})),
+    ])  # fmt: skip
+
+    # [tool.py-build-cmake.wheel]
+    wheel = pbc.insert(
+        ConfigOption("wheel",
+                     "Defines how to create the Wheel package.",
+                     default=DefaultValueValue({}),
+        ))  # fmt: skip
+    wheel_pth = ConfPath.from_string("pyproject.toml/tool/py-build-cmake/wheel")
+    wheel.insert_multiple([
+        BoolConfigOption("pure_python",
+                         "Indicate that this package contains no platform-"
+                         "specific binaries, only Python scripts and other "
+                         "platform-agnostic files. Setting this value to true "
+                         "causes the Wheel tags to be set to `py3-none-any`, "
+                         "and selects the `purelib` folder instead of "
+                         "`platlib`.\n"
+                         "If unset, the value depends on whether the `cmake` "
+                         "option is set.",
+                         "pure_python = true"),
+        ListOfStrConfigOption("python_tag",
+                              "Override the default Python tag for the Wheel "
+                              "package.\n"
+                              "If your package contains any Python extension "
+                              "modules, you want to set this to `auto`.\n"
+                              "For details about platform compatibility tags, "
+                              "see the PyPA specification: "
+                              "https://packaging.python.org/en/latest/"
+                              "specifications/platform-compatibility-tags",
+                              "python_tag = ['py2', 'py3']",
+                              convert_str_to_singleton=True,
+                              default=DefaultValueValue("auto")),
+        EnumConfigOption("python_abi",
+                         "Override the default ABI tag for the Wheel package.\n"
+                         "For packages with a Python extension module that "
+                         "make use of the full Python C API, this option "
+                         "should be set to `auto`.\n"
+                         "If your package does not contain Python extension "
+                         "modules (e.g. because it only includes executables "
+                         "to run as a subprocess, or only shared library files "
+                         "to be loaded using `ctypes`), you can set this to "
+                         "`none`.\n"
+                         "If your package only includes Python extension "
+                         "modules that use the CPython stable ABI, set this "
+                         "to `abi3` (see also `abi3_minimum_cpython_version` "
+                         "below).\n"
+                         "For details about platform compatibility tags, see "
+                         "the PyPA specification: https://packaging.python.org/"
+                         "en/latest/specifications/platform-compatibility-tags",
+                         "python_abi = 'none'",
+                         default=DefaultValueValue("auto"),
+                         options=["auto", "none", "abi3"]),
+        IntConfigOption("abi3_minimum_cpython_version",
+                        "If `python_abi` is set to `abi3`, only use the stable "
+                        "CPython API for CPython version that are newer than "
+                        "`abi3_minimum_version`. Useful for nanobind, which "
+                        "supports the stable ABI for CPython 12 and later.\n"
+                        "The Python version is encoded as a single integer, "
+                        "consisting of the major and minor version numbers, "
+                        "without a dot.",
+                        "abi3_minimum_cpython_version = 312",
+                        default=DefaultValueValue(32)),
+        ListOfStrConfigOption("abi_tag",
+                              "Override the default ABI tag for the Wheel "
+                              "package.\n"
+                              "It is not recommended to set this value in "
+                              "your pyproject.toml file directly. Instead, it "
+                              "is intended to be specified from the command "
+                              "line, or in a local override. "
+                              "See also: cross.abi.\n"
+                              "For details about platform compatibility tags, "
+                              "see the PyPA specification: "
+                              "https://packaging.python.org/en/latest/"
+                              "specifications/platform-compatibility-tags",
+                              "abi_tag = 'pypy310_pp73'",
+                              convert_str_to_singleton=True,
+                              default=NoDefaultValue()),
+        ListOfStrConfigOption("platform_tag",
+                              "Override the default platform tag for the Wheel "
+                              "package.\n"
+                              "The special value `guess` tries to select a "
+                              "sensible value based on the environment and the "
+                              "current Python interpreter (not supported when "
+                              "cross-compiling).\n"
+                              "It is not recommended to set this value in "
+                              "your pyproject.toml file directly. Instead, it "
+                              "is intended to be specified from the command "
+                              "line, or in a local override. "
+                              "See also: cross.arch.\n"
+                              "There are no checks in place to ensure that the "
+                              "platform tag applies to all files in the Wheel. "
+                              "If possible, you should use a tool such as "
+                              "auditwheel (https://github.com/pypa/auditwheel) or "
+                              "delocate (https://github.com/matthew-brett/delocate) "
+                              "to select the tag and to verify/fix the resulting "
+                              "package.\n"
+                              "For details about platform compatibility tags, "
+                              "see the PyPA specification: "
+                              "https://packaging.python.org/en/latest/"
+                              "specifications/platform-compatibility-tags",
+                              "platform_tag = 'manylinux_2_35_x86_64'",
+                              convert_str_to_singleton=True,
+                              default=NoDefaultValue()),
+        StringConfigOption("build_tag",
+                           "Add an optional build number to the Wheel "
+                           "package. "
+                           "Must start with a number and cannot contain "
+                           "`-` characters.\n"
+                           "It is not recommended to set this value in "
+                            "your pyproject.toml file directly. Instead, it "
+                            "is intended to be specified from the command "
+                            "line, or in a local override.\n"
+                           "For details about Wheel build tags, "
+                           "see the PyPA specification: "
+                           "https://packaging.python.org/en/latest/"
+                           "specifications/binary-distribution-format/"
+                           "#file-name-convention",
+                           "build_tag = '1'",
+                           default=NoDefaultValue()),
+    ])  # fmt: skip
+    # [tool.py-build-cmake.stubgen]
+    stubgen = pbc.insert(
+        ConfigOption("stubgen",
+                     "If specified, mypy's stubgen utility will be used to "
+                     "generate typed stubs for the Python files in the "
+                     "package.",
+        ))  # fmt: skip
+    stubgen.insert_multiple([
+        ListOfStrConfigOption("packages",
+                              "List of packages to generate stubs for, passed "
+                              "to stubgen as -p <?>."),
+        ListOfStrConfigOption("modules",
+                              "List of modules to generate stubs for, passed "
+                              "to stubgen as -m <?>."),
+        ListOfStrConfigOption("files",
+                              "List of files to generate stubs for, passed to "
+                              "stubgen without any flags."),
+        ListOfStrConfigOption("args",
+                              "List of extra arguments passed to stubgen.",
+                              default=DefaultValueValue([]),
+                              append_by_default=True),
+    ])  # fmt: skip
+
+    # [tool.py-build-cmake.{linux,windows,mac}]
+    for system in ["Linux", "Windows", "Mac"]:
+        name = system.lower()
+        opt = pbc.insert(
+            ConfigOption(name,
+                         f"Override options for {system}.",
+                         create_if_inheritance_target_exists=True,
+                         default=DefaultValueValue({}),
+            ))  # fmt: skip
+        opt.insert_multiple([
+            ConfigOption("editable",
+                         f"{system}-specific editable options.",
+                         inherit_from=editable_pth,
+                         create_if_inheritance_target_exists=True),
+            ConfigOption("sdist",
+                         f"{system}-specific sdist options.",
+                         inherit_from=sdist_pth,
+                         create_if_inheritance_target_exists=True),
+            MultiConfigOption("cmake",
+                         f"{system}-specific CMake options.",
+                         inherit_from=cmake_pth,
+                         create_if_inheritance_target_exists=True),
+            ConfigOption("wheel",
+                         f"{system}-specific Wheel options.",
+                         inherit_from=wheel_pth,
+                         create_if_inheritance_target_exists=True),
+        ])  # fmt: skip
+
+    # [tool.py-build-cmake.cross]
+    cross = pbc.insert(
+        ConfigOption("cross",
+                     "Causes py-build-cmake to cross-compile the project. See "
+                     "https://tttapa.github.io/py-build-cmake/"
+                     "Cross-compilation.html for more information.",
+        ))  # fmt: skip
+    cross.insert_multiple([
+        EnumConfigOption("os",
+                         "Operating system configuration to inherit from.",
+                         options=["linux", "mac", "windows"]),
+        StringConfigOption("implementation",
+                           "Identifier for the Python implementation.\n"
+                           "For details about platform compatibility tags, see "
+                           "the PyPA specification: https://packaging.python.org/"
+                           "en/latest/specifications/platform-compatibility-tags",
+                           "implementation = 'cp' # CPython",
+                           default=NoDefaultValue("same as current interpreter")),
+        StringConfigOption("version",
+                           "Python version, major and minor, without dots.\n"
+                           "For details about platform compatibility tags, see "
+                           "the PyPA specification: https://packaging.python.org/"
+                           "en/latest/specifications/platform-compatibility-tags",
+                           "version = '310' # 3.10",
+                           default=NoDefaultValue("same as current interpreter")),
+        StringConfigOption("abi",
+                           "Python ABI.\n"
+                           "For details about platform compatibility tags, see "
+                           "the PyPA specification: https://packaging.python.org/"
+                           "en/latest/specifications/platform-compatibility-tags",
+                           "abi = 'cp310'",
+                           default=NoDefaultValue("same as current interpreter")),
+        StringConfigOption("arch",
+                           "Platform tag, consisting of the operating system "
+                           "and architecture (no dots or dashes, only "
+                           "underscores, all lowercase).\n"
+                           "For details about platform compatibility tags, see "
+                           "the PyPA specification: https://packaging.python.org/"
+                           "en/latest/specifications/platform-compatibility-tags",
+                           "arch = 'linux_x86_64'",
+                           default=NoDefaultValue("same as current interpreter")),
+        PathConfigOption("prefix",
+                         "Root path of the Python installation. "
+                         "Used to set the `Python3_ROOT_DIR` CMake hint, "
+                         "see https://cmake.org/cmake/help/latest/module/"
+                         "FindPython3.html#hints.",
+                         base_path=RelativeToCurrentConfig(project_path),
+                         allow_abs=True,
+                         is_folder=True,
+                         must_exist=True,
+                         default=None),
+        PathConfigOption("library",
+                         "Python library file (.so on Linux, .lib on Windows). "
+                         "Used to set the `Python3_LIBRARY` CMake artifact, "
+                         "see https://cmake.org/cmake/help/latest/module/"
+                         "FindPython3.html#artifacts-specification.",
+                         base_path=RelativeToCurrentConfig(project_path),
+                         allow_abs=True,
+                         is_folder=False,
+                         must_exist=True,
+                         default=None),
+        PathConfigOption("include_dir",
+                         "Python include directory (containing Python.h). "
+                         "Used to set the `Python3_INCLUDE_DIR` CMake "
+                         "artifact, "
+                         "see https://cmake.org/cmake/help/latest/module/"
+                         "FindPython3.html#artifacts-specification.",
+                         base_path=RelativeToCurrentConfig(project_path),
+                         allow_abs=True,
+                         is_folder=True,
+                         must_exist=True,
+                         default=None),
+        PathConfigOption("toolchain_file",
+                         "CMake toolchain file to use. See "
+                         "https://cmake.org/cmake/help/book/mastering-cmake"
+                         "/chapter/Cross%20Compiling%20With%20CMake.html for "
+                         "more information.",
+                         default=None,
+                         base_path=RelativeToCurrentConfig(project_path),
+                         must_exist=not test,
+                         allow_abs=True,
+                         is_folder=False),
+        ConfigOption("editable",
+                     "Override editable options when cross-compiling.",
+                     inherit_from=editable_pth,
+                     create_if_inheritance_target_exists=True),
+        ConfigOption("sdist",
+                     "Override sdist options when cross-compiling.",
+                     inherit_from=sdist_pth,
+                     create_if_inheritance_target_exists=True),
+        MultiConfigOption("cmake",
+                     "Override CMake options when cross-compiling.",
+                     inherit_from=cmake_pth,
+                     create_if_inheritance_target_exists=True),
+        ConfigOption("wheel",
+                     "Override Wheel options when cross-compiling.",
+                     inherit_from=wheel_pth,
+                     create_if_inheritance_target_exists=True),
+    ])  # fmt: skip
+
+    return root
+
+
+def get_component_options(project_path: Path, *, test: bool = False):
+    root = ConfigOption("root")
+    pyproject = root.insert(UncheckedConfigOption("pyproject.toml"))
+    project = pyproject.insert(UncheckedConfigOption("project"))
+    project.insert(UncheckedConfigOption("name", default=RequiredValue()))
+    tool = pyproject.insert(
+        UncheckedConfigOption("tool",
+                              default=DefaultValueValue({}),
+                              create_if_inheritance_target_exists=True,
+        ))  # fmt: skip
+    pbc = tool.insert(
+        ConfigOption("py-build-cmake",
+                     default=DefaultValueValue({}),
+                     create_if_inheritance_target_exists=True,
+        ))  # fmt: skip
+    # TODO: we should warn if these are present in a component config
+    pbc.insert_multiple([
+        UncheckedConfigOption("module"),
+        UncheckedConfigOption("editable"),
+        UncheckedConfigOption("sdist"),
+        UncheckedConfigOption("cmake"),
+        UncheckedConfigOption("wheel"),
+        UncheckedConfigOption("stubgen"),
+        UncheckedConfigOption("linux"),
+        UncheckedConfigOption("windows"),
+        UncheckedConfigOption("mac"),
+        UncheckedConfigOption("cross"),
+    ])  # fmt: skip
+
+    # [tool.py-build-cmake.main_project]
+    pbc.insert(
+        PathConfigOption("main_project",
+                         "Directory containing the main pyproject.toml file.",
+                         default=DefaultValueValue(".."),
+                         base_path=RelativeToProject(project_path),
+                         must_exist=not test,
+    ))  # fmt: skip
+    # [tool.py-build-cmake.component]
+    component = pbc.insert(
+        MultiConfigOption("component",
+                          "Options for a separately packaged component.",
+                          default=DefaultValueValue({}),
+    ))  # fmt: skip
+    component.insert_multiple([
+        ListOfStrConfigOption('build_presets',
+                              "CMake presets to use for building. Passed as "
+                              "`--preset <?>` during the build phase, once "
+                              "for each preset.",
+                              default=None,
+                              convert_str_to_singleton=True),
+        ListOfStrConfigOption("build_args",
+                              "Extra arguments passed to the build step.",
+                              "build_args = [\"-j\", \"--target\", \"foo\"]",
+                              default=None,
+                              append_by_default=True),
+        ListOfStrConfigOption("build_tool_args",
+                              "Extra arguments passed to the build tool in the "
+                              "build step (e.g. to Make or Ninja).",
+                              "build_tool_args = "
+                              "[\"--verbose\", \"-d\", \"explain\"]",
+                              default=None,
+                              append_by_default=True),
+        BoolConfigOption("install_only",
+                         "Do not build the project, only install it.",
+                         "install_only = true",
+                         default=DefaultValueValue(False)),
+        ListOfStrConfigOption("install_args",
+                              "Extra arguments passed to the install step.",
+                              "install_args = [\"--strip\"]",
+                              default=None,
+                              append_by_default=True),
+        ListOfStrConfigOption("install_components",
+                              "List of components to install, the install step "
+                              "is executed once for each component, with the "
+                              "option `--component <?>`.",
+                              default=RequiredValue()),
+    ])  # fmt: skip
+
+    return root
diff --git a/src/py_build_cmake/config/options/string.py b/src/py_build_cmake/config/options/string.py
new file mode 100644
index 0000000..9c8c455
--- /dev/null
+++ b/src/py_build_cmake/config/options/string.py
@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import os
+from copy import copy
+from dataclasses import dataclass
+
+from ...common import ConfigError
+from .config_option import ConfigOption
+from .value_reference import OverrideActionEnum, ValueReference
+
+
+@dataclass
+class StringOption:
+    clear: bool = False
+    value: str | None = None
+    append: str | None = None
+    append_path: str | None = None
+    prepend: str | None = None
+    prepend_path: str | None = None
+    remove: list[str] | None = None
+
+    @classmethod
+    def create(cls, value: str):
+        return cls(value=value)
+
+    @classmethod
+    def from_values(cls, values: ValueReference):  # noqa: PLR0911
+        val = values.values
+        if values.action == OverrideActionEnum.Clear:
+            assert val is None
+            return cls(clear=True)
+        # The value should be a string, unless it's a "remove" action, then
+        # list[str] is also fine
+        msg = f"Type of {values.value_path} should be {str}, "
+        msg += f"not {type(values.values)}"
+        if values.action == OverrideActionEnum.Remove:
+            if isinstance(val, list):
+                if not all(isinstance(v, str) for v in val):
+                    raise ConfigError(msg)
+            elif not isinstance(val, str):
+                raise ConfigError(msg)
+            val_list: list[str] = val if isinstance(val, list) else [val]
+            return cls(remove=val_list)
+        if not isinstance(val, str):
+            raise ConfigError(msg)
+        if values.action in (OverrideActionEnum.Default, OverrideActionEnum.Assign):
+            return cls(value=val)
+        if values.action == OverrideActionEnum.Append:
+            return cls(append=val)
+        if values.action == OverrideActionEnum.AppendPath:
+            return cls(append_path=val)
+        if values.action == OverrideActionEnum.Prepend:
+            return cls(prepend=val)
+        if values.action == OverrideActionEnum.PrependPath:
+            return cls(prepend_path=val)
+        msg = f"Invalid action {values.action}"
+        raise AssertionError(msg)
+
+    @staticmethod
+    def _join_path(a, b):
+        return a + os.pathsep + b if a and b else a + b
+
+    def override(self, new: StringOption):  # noqa: PLR0912
+        # Clearing always propagates
+        if new.clear:
+            return copy(new)
+        old = copy(self)
+        # If we're overriding with a value, the old value is not used
+        if new.value is not None:
+            old.value = new.value
+            old.append = new.append
+            old.append_path = new.append_path
+            old.prepend = new.prepend
+            old.prepend_path = new.prepend_path
+            old.remove = []
+            return old
+        # Otherwise, we're simply appending to or removing from the old value,
+        # and these changes are propagated down to the old value.
+        if new.remove is not None:
+            old.remove = (old.remove or []) + new.remove
+            for r in new.remove:
+                if old.value:
+                    old.value = old.value.replace(r, "")
+                if old.prepend:
+                    old.prepend = old.prepend.replace(r, "")
+                if old.prepend_path:
+                    old.prepend_path = old.prepend_path.replace(r, "")
+                if old.append:
+                    old.append = old.append.replace(r, "")
+                if old.append_path:
+                    old.append_path = old.append_path.replace(r, "")
+        if new.append is not None:
+            old.append = (old.append or "") + new.append
+        if new.append_path is not None:
+            old.append_path = self._join_path(old.append_path or "", new.append_path)
+        if new.prepend is not None:
+            old.prepend = new.prepend + (old.prepend or "")
+        if new.prepend_path is not None:
+            old.prepend_path = self._join_path(new.prepend_path, old.prepend_path or "")
+        return old
+
+    def finalize(self) -> str | None:
+        empty = True
+        final = ""
+        # TODO: combining append and append_path may result in weird order
+        if self.value is not None:
+            empty = False
+            final = self.value
+        if self.append is not None:
+            empty = False
+            final = final + self.append
+        if self.append_path is not None:
+            empty = False
+            final = StringOption._join_path(final, self.append_path)
+        if self.prepend is not None:
+            empty = False
+            final = self.prepend + final
+        if self.prepend_path is not None:
+            empty = False
+            final = StringOption._join_path(self.prepend_path, final)
+        return None if (empty and self.clear) else final
+
+
+class StringConfigOption(ConfigOption):
+    def get_typename(self, md: bool = False) -> str:
+        return "string"
+
+    def verify(self, values: ValueReference):
+        return StringOption.from_values(values)
+
+    def override(self, old_value, new_value):
+        new, old = new_value.values, copy(old_value.values)
+        if old is None:  # No previous value
+            old = StringOption()
+        assert isinstance(new, StringOption)
+        assert isinstance(old, StringOption)
+        return old.override(new)
+
+    def finalize(self, values: ValueReference):
+        if values.values is None:
+            return None
+        val = values.values
+        if isinstance(val, str):
+            return val
+        assert isinstance(val, StringOption)
+        return val.finalize()
diff --git a/src/py_build_cmake/config/options/value_reference.py b/src/py_build_cmake/config/options/value_reference.py
new file mode 100644
index 0000000..f74ed42
--- /dev/null
+++ b/src/py_build_cmake/config/options/value_reference.py
@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from .config_path import ConfPath
+
+
+class OverrideActionEnum(Enum):
+    Default = "?="
+    Assign = "="
+    Append = "+="
+    AppendPath = "+=(path)"
+    Prepend = "=+"
+    PrependPath = "=+(path)"
+    Remove = "-="
+    Clear = "=!"
+
+    def override_string(self, old: str, new: str) -> str:
+        return {
+            OverrideActionEnum.Default: lambda: new,
+            OverrideActionEnum.Assign: lambda: new,
+            OverrideActionEnum.Append: lambda: old + new,
+            OverrideActionEnum.AppendPath: lambda: (
+                old + os.pathsep + new if old and new else old + new
+            ),
+            OverrideActionEnum.Prepend: lambda: new + old,
+            OverrideActionEnum.PrependPath: lambda: (
+                new + os.pathsep + old if old and new else old + new
+            ),
+            OverrideActionEnum.Remove: lambda: old.replace(new, ""),
+        }[self]()
+
+
+@dataclass
+class OverrideAction:
+    action: OverrideActionEnum
+    values: Any
+
+
+class ValueReference:
+    def __init__(
+        self,
+        value_path: ConfPath,
+        values: dict | OverrideAction | Any,
+        action: OverrideActionEnum = OverrideActionEnum.Default,
+    ) -> None:
+        self.value_path = value_path
+        self.action = action
+        self.values: dict | Any
+        if isinstance(values, OverrideAction):
+            self.action = values.action
+            self.values = values.values
+        else:
+            self.values = values
+
+    def is_value_set(self, path: str | ConfPath):
+        values = self.values
+        if values is None:
+            return False
+        if isinstance(path, str):
+            return path in values
+        while path:
+            name, path = path.split_front()
+            if values is None or name not in values:
+                return False
+            values = values[name]
+        return True
+
+    def get_value(self, path: str | ConfPath):
+        values = self.values
+        if isinstance(path, str):
+            if values is None:
+                raise KeyError(path)
+            return values[path]
+        while path:
+            name, path = path.split_front()
+            if values is None:
+                raise KeyError(name)
+            values = values[name]
+        return values
+
+    def set_value(self, path: str | ConfPath, val: Any):
+        values = self.values
+        if isinstance(path, str):
+            if values is None:
+                return False
+            values[path] = val
+            return True
+        while True:
+            if values is None:
+                return False
+            name, path = path.split_front()
+            if not path:
+                values[name] = val
+                return True
+            if name not in values:
+                return False
+            values = values[name]
+
+    def clear_value(self, path: str | ConfPath):
+        values = self.values
+        if isinstance(path, str):
+            if values is None:
+                return
+            values.pop(path, None)
+            return
+        while True:
+            name, path = path.split_front()
+            if values is None:
+                return
+            if not path:
+                values.pop(name, None)
+                return
+            if name not in values:
+                return
+            values = values[name]
+
+    def set_value_default(self, path: str | ConfPath, val: Any):
+        if self.values is None:
+            return None
+        if isinstance(path, str):
+            self.values.setdefault(path, val)
+            return True
+        values = self.values
+        while True:
+            if values is None:
+                return False
+            name, path = path.split_front()
+            if not path:
+                values.setdefault(name, val)
+                return True
+            if name not in values:
+                return False
+            values = values[name]
+
+    def sub_ref(self, name: str | ConfPath) -> ValueReference:
+        if isinstance(name, ConfPath) and len(name.pth) == 1:
+            name = name.pth[0]
+        if isinstance(name, str):
+            if not self.is_value_set(name):
+                raise KeyError(name)
+            return ValueReference(
+                value_path=self.value_path.join(name),
+                values=self.values[name],
+            )
+        if not name:
+            return self
+        name, rem = name.split_front()
+        return self.sub_ref(name).sub_ref(rem)
+
+    def __repr__(self) -> str:
+        return f"<ValueReference to: '{self.value_path}'>"
diff --git a/src/py_build_cmake/config/options/verify.py b/src/py_build_cmake/config/options/verify.py
new file mode 100644
index 0000000..a8fe349
--- /dev/null
+++ b/src/py_build_cmake/config/options/verify.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from copy import copy
+
+from ...common import ConfigError
+from .config_reference import ConfigReference
+from .value_reference import OverrideActionEnum, ValueReference
+
+
+class ConfigVerifier:
+    def __init__(
+        self, root: ConfigReference, ref: ConfigReference, values: ValueReference
+    ) -> None:
+        self.root = root
+        self.ref = ref
+        self.values = values
+
+    def verify(self):
+        # If this option should be cleared, it shouldn't have a value
+        if (
+            self.values.action == OverrideActionEnum.Clear
+            and self.values.values is not None
+        ):
+            msg = f'Operation "clear" ({self.values.action.value}) '
+            msg += f"cannot have a value in {self.values.value_path}"
+            raise ConfigError(msg)
+        # Verify our own option
+        verified_values = ValueReference(
+            self.values.value_path,
+            self.ref.config.verify(copy(self.values)),
+            self.values.action,
+        )
+        # Verify our sub-options
+        for ref, sub_val in self.ref.iter_set_sub_options(verified_values):
+            verified = ConfigVerifier(
+                root=self.root,
+                ref=ref.resolve_inheritance(self.root),
+                values=sub_val,
+            ).verify()
+            rel = sub_val.value_path.relative_to(verified_values.value_path)
+            verified_values.set_value(rel, verified)
+        return verified_values.values
diff --git a/src/py_build_cmake/config/quirks.py b/src/py_build_cmake/config/quirks.py
new file mode 100644
index 0000000..f3b265e
--- /dev/null
+++ b/src/py_build_cmake/config/quirks.py
@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import configparser
+import contextlib
+import logging
+import os
+import platform
+import re
+import sys
+import sysconfig
+from pathlib import Path
+from typing import Any
+
+from distlib.util import (  # type: ignore[import-untyped]
+    get_platform as get_platform_dashes,
+)
+
+from ..common.util import (
+    archflags_to_platform_tag,
+    platform_to_platform_tag,
+    python_sysconfig_platform_to_cmake_platform_win,
+    python_sysconfig_platform_to_cmake_processor_win,
+)
+from ..config.options.config_option import MultiConfigOption
+from .options.cmake_opt import CMakeOption
+from .options.config_path import ConfPath
+from .options.string import StringOption
+from .options.value_reference import ValueReference
+
+logger = logging.getLogger(__name__)
+
+
+def get_python_lib(library_dirs: str | list[str] | None) -> Path | None:
+    """Return the path the the first python<major><minor>.lib or
+    python<major>.lib file in any of the library_dirs.
+    Returns None if no such file exists."""
+    if library_dirs is None:
+        return None
+    if isinstance(library_dirs, str):
+        library_dirs = [library_dirs]
+
+    def possible_locations():
+        v = sys.version_info
+        py3xlib = lambda d: Path(d) / f"python{v.major}{v.minor}.lib"
+        py3lib = lambda d: Path(d) / f"python{v.major}.lib"
+        yield from map(py3xlib, library_dirs)
+        yield from map(py3lib, library_dirs)
+
+    try:
+        return next(filter(Path.exists, possible_locations()))
+    except StopIteration:
+        return None
+
+
+def cross_compile_win(
+    config: ValueReference, plat_name, library_dirs, cmake_plat, cmake_proc
+):
+    """Update the configuration to include a cross-compilation configuration
+    that builds for the given platform and processor. If library_dirs contains
+    a compatible Python library, it is also included in the configuration, as
+    well as the path to the Python installation's root directory, so CMake is
+    able to locate Python correctly."""
+    logger.info(
+        "DIST_EXTRA_CONFIG.build_ext specified plat_name that is different from the current platform. "
+        "Automatically enabling cross-compilation for %s",
+        cmake_plat,
+    )
+    assert not config.is_value_set("cross")
+    all = MultiConfigOption.default_index
+    options = {
+        "CMAKE_SYSTEM_NAME": CMakeOption.create("Windows", "STRING"),
+        "CMAKE_SYSTEM_PROCESSOR": CMakeOption.create(cmake_proc, "STRING"),
+        "CMAKE_GENERATOR_PLATFORM": CMakeOption.create(cmake_plat, "STRING"),
+    }
+    cross_cfg = {
+        "os": "windows",
+        "arch": StringOption.create(platform_to_platform_tag(plat_name)),
+        "cmake": {all: {"options": options}},
+    }
+    python_lib = get_python_lib(library_dirs)
+    if python_lib is not None:
+        cross_cfg["library"] = str(python_lib)
+        python_root = python_lib.parent.parent
+        if (python_root / "include").exists():
+            cross_cfg["root"] = str(python_root)
+    else:
+        logger.warning(
+            "Python library was not found in DIST_EXTRA_CONFIG.build_ext.library_dirs."
+        )
+    config.set_value("cross", cross_cfg)
+
+
+def handle_cross_win(
+    config: ValueReference, plat_name: str, library_dirs: str | list[str] | None
+):
+    """Try to configure cross-compilation for the given Windows platform.
+    library_dirs should contain the directory with the Python library."""
+    plat_proc = (
+        python_sysconfig_platform_to_cmake_platform_win(plat_name),
+        python_sysconfig_platform_to_cmake_processor_win(plat_name),
+    )
+    if all(plat_proc):
+        cross_compile_win(config, plat_name, library_dirs, *plat_proc)
+    else:
+        logger.warning(
+            "Cross-compilation setup skipped because the platform %s is unknown",
+            plat_name,
+        )
+
+
+def handle_dist_extra_config_win(config: ValueReference, dist_extra_conf: str):
+    """Read the given distutils configuration file and use it to configure
+    cross-compilation if appropriate."""
+    distcfg = configparser.ConfigParser()
+    distcfg.read(dist_extra_conf)
+
+    library_dirs = distcfg.get("build_ext", "library_dirs", fallback="")
+    plat_name = distcfg.get("build_ext", "plat_name", fallback="")
+
+    if plat_name and plat_name != sysconfig.get_platform():
+        handle_cross_win(config, plat_name, library_dirs)
+
+
+def config_quirks_win(config: ValueReference):
+    """
+    Explanation:
+    The cibuildwheel tool sets the DIST_EXTRA_CONFIG environment variable when
+    cross-compiling. It points to a configuration file that contains the path
+    to the correct Python library (.lib), as well as the name of the platform
+    to compile for.
+    If the user did not specify a custom cross-compilation configuration,
+    we will automatically add a minimal cross-compilation configuration that
+    points CMake to the right Python library, and that selects the right
+    CMake/Visual Studio platform.
+    """
+    dist_extra_conf = os.getenv("DIST_EXTRA_CONFIG")
+    if dist_extra_conf is not None:
+        if config.is_value_set("cross"):
+            logger.warning(
+                "Cross-compilation configuration was not empty, so I'm ignoring DIST_EXTRA_CONFIG"
+            )
+        elif not config.is_value_set("cmake"):
+            logger.warning(
+                "CMake configuration was empty, so I'm ignoring DIST_EXTRA_CONFIG"
+            )
+        else:
+            handle_dist_extra_config_win(config, dist_extra_conf)
+
+
+def cross_compile_mac(config: ValueReference, archs):
+    """Update the configuration to include a cross-compilation configuration
+    that builds for the given architectures."""
+    logger.info(
+        "ARCHFLAGS was specified. Automatically enabling cross-compilation for %s (native platform: %s)",
+        ", ".join(archs),
+        platform.machine(),
+    )
+    assert not config.is_value_set("cross")
+    all = MultiConfigOption.default_index
+    options = {
+        "CMAKE_SYSTEM_NAME": CMakeOption.create("Darwin", "STRING"),
+        "CMAKE_OSX_ARCHITECTURES": CMakeOption.create(archs, "STRING"),
+    }
+    cross_cfg: dict[str, Any] = {
+        "os": "mac",
+        "cmake": {all: {"options": options}},
+    }
+    plat_tag = archflags_to_platform_tag(archs)
+    if plat_tag:
+        cross_arch = get_platform_dashes().split("-")
+        cross_arch[-1] = plat_tag
+        cross_cfg["arch"] = StringOption.create(
+            platform_to_platform_tag("_".join(cross_arch))
+        )
+    if sys.implementation.name == "cpython":
+        version = "".join(map(str, sys.version_info[:2]))
+        abi = getattr(sys, "abiflags", "")
+        cross_cfg["cmake"][all]["env"] = {
+            "SETUPTOOLS_EXT_SUFFIX": StringOption.create(
+                f".cpython-{version}{abi}-darwin.so"
+            )
+        }
+    config.set_value("cross", cross_cfg)
+
+
+def config_quirks_mac(config: ValueReference):
+    """Sets CMAKE_OSX_ARCHITECTURES if $ENV{ARCHFLAGS} is set
+    on macOS. This ensures compatibility with cibuildwheel. If the interpreter
+    architecture is not in the ARCHFLAGS, also enables cross-compilation."""
+    archflags = os.getenv("ARCHFLAGS")
+    if not archflags:
+        return
+    archs = list(re.findall(r"-arch +(\S+)", archflags))
+    if not archs:
+        logger.warning(
+            "ARCHFLAGS was set, but its value was not valid, so I'm ignoring it"
+        )
+        return
+    if config.is_value_set("cross"):
+        logger.warning(
+            "Cross-compilation configuration was not empty, so I'm ignoring ARCHFLAGS"
+        )
+        return
+    if not config.is_value_set("cmake"):
+        logger.warning("CMake configuration was empty, so I'm ignoring ARCHFLAGS")
+        return
+    if platform.machine() not in archs:
+        cross_compile_mac(config, archs)
+    else:
+        logger.info(
+            "ARCHFLAGS was set, adding CMAKE_OSX_ARCHITECTURES to cmake.options (%s, native platform: %s)",
+            ", ".join(archs),
+            platform.machine(),
+        )
+        all = MultiConfigOption.default_index
+        cmake_pth = ConfPath(("cmake", all))
+        config.set_value_default(cmake_pth, {})
+        config.set_value_default(cmake_pth.join("options"), {})
+        config.set_value_default(
+            cmake_pth.join("options").join("CMAKE_OSX_ARCHITECTURES"),
+            CMakeOption.create(archs, "STRING"),
+        )
+
+
+def config_quirks_pypy(config: ValueReference):
+    if sys.version_info < (3, 8):
+        with contextlib.suppress(KeyError):
+            del config.values["stubgen"]
+            logger.info("Mypy is not supported on PyPy <3.8, disabling stubgen")
+
+
+def config_quirks(config: ValueReference):
+    dispatch = {
+        "Windows": config_quirks_win,
+        "Darwin": config_quirks_mac,
+    }.get(platform.system())
+    if dispatch is not None:
+        dispatch(config)
+    dispatch = {
+        "pypy": config_quirks_pypy,
+    }.get(sys.implementation.name)
+    if dispatch is not None:
+        dispatch(config)
diff --git a/src/py_build_cmake/config_options.py b/src/py_build_cmake/config_options.py
deleted file mode 100644
index dbc4b38..0000000
--- a/src/py_build_cmake/config_options.py
+++ /dev/null
@@ -1,770 +0,0 @@
-"""
-Classes to define hierarchical configuration options which support inheriting
-from other options, default values, overriding options, etc.
-"""
-
-from abc import ABC, abstractmethod
-from copy import deepcopy
-from dataclasses import dataclass
-import os
-from pathlib import Path
-from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Union
-
-from flit_core.config import ConfigError  # type: ignore
-
-ConfPath = Tuple[str, ...]
-ConfValue = Optional[Union[bool, str, List[str], Dict[str, Any]]]
-Conf = Dict[str, Any]
-
-
-def pth(s: str) -> ConfPath:
-    if not s:
-        return ()
-    return tuple(s.split('/'))
-
-
-def pth2str(p: ConfPath) -> str:
-    return '/'.join(p)
-
-
-def joinpth(p1: ConfPath, p2: ConfPath) -> ConfPath:
-    while p1 and p2 and p2[0] == '^':
-        p1 = p1[:-1]
-        p2 = p2[1:]
-    return p1 + p2
-
-
-def hasparent(path: ConfPath) -> bool:
-    return len(path) >= 1
-
-
-def parent(path: ConfPath) -> ConfPath:
-    if not hasparent(path):
-        raise RuntimeError(f"Path {pth2str(path)} does not have a parent")
-    return path[:-1]
-
-
-def basename(path: ConfPath) -> str:
-    return path[-1]
-
-
-class ConfigNode:
-
-    def __init__(self,
-                 value: ConfValue = None,
-                 sub: Optional[Dict[str, 'ConfigNode']] = None) -> None:
-        self.value: ConfValue = value
-        self.sub: Optional[Dict[str, 'ConfigNode']] = sub
-
-    @classmethod
-    def from_dict(cls, d: dict):
-        node = cls()
-        node.sub = {}
-        for k, v in d.items():
-            if isinstance(v, dict):
-                node.sub[k] = cls.from_dict(v)
-            else:
-                node.sub[k] = cls(value=v)
-        return node
-
-    def to_dict(self):
-        if self.sub is None:
-            return self.value
-        return {k: v.to_dict() for k, v in self.sub.items()}
-
-    def iter_dfs(self, path: ConfPath = ()):
-        yield path, self.value
-        if self.sub is not None:
-            for name, sub in self.sub.items():
-                for y in sub.iter_dfs(path + (name, )):
-                    yield y
-
-    def __getitem__(self, key):
-        if isinstance(key, str):
-            if self.sub is None:
-                raise KeyError()
-            return self.sub[key]
-        elif isinstance(key, tuple):
-            if len(key) == 0:
-                return self
-            elif self.sub is None:
-                raise KeyError()
-            else:
-                return self.sub[key[0]][key[1:]]
-        else:
-            raise TypeError(key)
-
-    def get(self, key: ConfPath, default=None):
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def setdefault(self, path: ConfPath, default: Any):
-        tgt = self[parent(path)]
-        if tgt.sub is None:
-            tgt.sub = {}
-        return tgt.sub.setdefault(basename(path), default)
-
-    def contains(self, path: ConfPath):
-        try:
-            self[path]
-            return True
-        except KeyError:
-            return False
-
-
-@dataclass
-class DefaultValueWrapper:
-    value: ConfValue
-
-
-class DefaultValue(ABC):
-
-    @abstractmethod
-    def get_default(self, rootopts: 'ConfigOption', opt: 'ConfigOption',
-                    cfg: ConfigNode, cfgpath: ConfPath,
-                    optpath: ConfPath) -> Optional[DefaultValueWrapper]:
-        ...
-
-    @abstractmethod
-    def get_name(self) -> str:
-        ...
-
-
-class DefaultValueValue(DefaultValue):
-
-    def __init__(self, value: ConfValue) -> None:
-        self.value: ConfValue = value
-
-    def get_default(self, rootopts: 'ConfigOption', opt: 'ConfigOption',
-                    cfg: ConfigNode, cfgpath: ConfPath,
-                    optpath: ConfPath) -> Optional[DefaultValueWrapper]:
-        return DefaultValueWrapper(self.value)
-
-    def get_name(self):
-        if isinstance(self.value, bool):
-            return str(self.value).lower()
-        return repr(self.value)
-
-
-class NoDefaultValue(DefaultValue):
-
-    def __init__(self, name='none'):
-        self.name = name
-
-    def get_default(self, rootopts: 'ConfigOption', opt: 'ConfigOption',
-                    cfg: ConfigNode, cfgpath: ConfPath,
-                    optpath: ConfPath) -> Optional[DefaultValueWrapper]:
-        return None
-
-    def get_name(self):
-        return self.name
-
-
-class MissingDefaultError(ConfigError):
-    pass
-
-
-class RequiredValue(DefaultValue):
-
-    def get_default(self, rootopts: 'ConfigOption', opt: 'ConfigOption',
-                    cfg: ConfigNode, cfgpath: ConfPath,
-                    optpath: ConfPath) -> Optional[DefaultValueWrapper]:
-        raise MissingDefaultError(f'{pth2str(cfgpath)} requires a value')
-
-    def get_name(self):
-        return 'required'
-
-
-class RefDefaultValue(DefaultValue):
-
-    def __init__(self, path: ConfPath, relative: bool = False) -> None:
-        super().__init__()
-        self.path: ConfPath = path
-        self.relative = relative
-
-    def get_default(self, rootopts: 'ConfigOption', opt: 'ConfigOption',
-                    cfg: ConfigNode, cfgpath: ConfPath,
-                    optpath: ConfPath) -> Optional[DefaultValueWrapper]:
-        abscfgpath = absoptpath = self.path
-        if self.relative:
-            absoptpath = joinpth(optpath, ('^', ) + absoptpath)
-            abscfgpath = joinpth(cfgpath, ('^', ) + abscfgpath)
-        opt = rootopts.get(absoptpath)
-        if opt is None:
-            raise ValueError("DefaultValue: reference to nonexisting option "
-                             f"{pth2str(absoptpath)}")
-        return opt.update_default(rootopts, cfg, abscfgpath, absoptpath)
-
-    def get_name(self) -> str:
-        r = pth2str(self.path).replace('^', '..')
-        if not self.relative:
-            r = '/' + r
-        return r
-
-
-class ConfigOption:
-
-    allow_unknown_keys = False
-
-    def __init__(self,
-                 name: str,
-                 description: str = '',
-                 example: str = '',
-                 default: DefaultValue = NoDefaultValue(),
-                 inherit_from: Optional[ConfPath] = None,
-                 create_if_inheritance_target_exists: bool = False) -> None:
-        self.name = name
-        self.description = description
-        self.example = example
-        self.sub: Dict[str, 'ConfigOption'] = {}
-        self.default: DefaultValue = default
-        self.inherit_from: Optional[ConfPath] = inherit_from
-        self.create_if_inheritance_target_exists = create_if_inheritance_target_exists
-
-    def get_typename(self, md: bool = False):
-        return None
-
-    def insert(self, opt: 'ConfigOption'):
-        assert opt.name not in self.sub
-        self.sub[opt.name] = opt
-        return self.sub[opt.name]
-
-    def insert_multiple(self, opts: Iterable['ConfigOption']):
-        for opt in opts:
-            self.insert(opt)
-
-    def iter_opt_paths(self) -> Iterator[ConfPath]:
-        """DFS of the option tree."""
-        for name, subopt in self.sub.items():
-            yield (name, )
-            for p in subopt.iter_opt_paths():
-                yield (name, ) + p
-
-    def iter_leaf_opt_paths(self) -> Iterator[ConfPath]:
-        """DFS of the option tree."""
-        if not self.sub:
-            yield ()
-        else:
-            for name, subopt in self.sub.items():
-                for p in subopt.iter_leaf_opt_paths():
-                    yield (name, ) + p
-
-    def iter_dfs(self, path: ConfPath = ()):
-        yield path, self
-        for name, sub in self.sub.items():
-            for y in sub.iter_dfs(path + (name, )):
-                yield y
-
-    def __getitem__(self, key) -> 'ConfigOption':
-        if isinstance(key, str):
-            return self.sub[key]
-        elif isinstance(key, tuple):
-            if len(key) == 0:
-                return self
-            else:
-                return self.sub[key[0]][key[1:]]
-        else:
-            raise TypeError(key)
-
-    def get(self, key: ConfPath, default=None):
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def setdefault(self, path: ConfPath, default: Any):
-        tgt = self[parent(path)]
-        if tgt.sub is None:
-            tgt.sub = {}
-        return tgt.sub.setdefault(basename(path), default)
-
-    def contains(self, path: ConfPath):
-        try:
-            self[path]
-            return True
-        except KeyError:
-            return False
-
-    def inherit(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-                selfpth: ConfPath):
-        superpth = self.inherit_from
-        if superpth is not None:
-            # If the super option is not set, there's nothing to inherit
-            supercfg = cfg.get(superpth)
-            if supercfg is None:
-                return
-
-            # If this option is not set, but the super option is,
-            # create our own config as well, including all of its parents,
-            # but only if create_if_inheritance_target_exists is set on those
-            # options
-            selfcfg = self.create_parent_config_for_inheritance(
-                rootopts, cfg, selfpth)
-            if selfcfg is None:
-                return
-
-            # Find the option we inherit from and make sure it exists
-            superopt = rootopts.get(superpth)
-            if superopt is None:
-                raise ValueError(f'{pth2str(superpth)} is not a valid option')
-
-            # Create a copy of the config of our super-option and override it
-            # with our own config
-            supercfg = deepcopy(supercfg)
-            superopt.explicit_override(self, supercfg, superpth, selfcfg,
-                                       selfpth)
-            selfcfg.sub = supercfg.sub
-        if self.sub:
-            for name, sub in self.sub.items():
-                sub.inherit(rootopts, cfg, selfpth + (name, ))
-
-    @staticmethod
-    def create_parent_config_for_inheritance(rootopts: 'ConfigOption',
-                                             cfg: ConfigNode,
-                                             selfpth: ConfPath):
-        """
-        Loop over all parent options of selfpth in rootopts and default-
-        initialize their configuration in cfg to empty ConfigNodes if the 
-        option's create_if_inheritance_target_exists is set to True.
-        Returns cfg[selfpth] or None if parents were not created because of
-        create_if_inheritance_target_exists.
-        """
-        selfcfg = None
-        p: ConfPath = ()
-        opt = rootopts
-        create_paths: List[ConfPath] = []
-        for s in selfpth:
-            p += s,
-            opt = opt[s]
-            selfcfg = cfg.get(p)
-            if selfcfg is None:
-                if not opt.create_if_inheritance_target_exists:
-                    return None
-                create_paths.append(p)
-        for p in create_paths:
-            selfcfg = cfg.setdefault(p, ConfigNode(sub={}))
-        return selfcfg
-
-    def explicit_override(self, rootopts: 'ConfigOption', selfcfg: ConfigNode,
-                          selfpth: ConfPath, overridecfg: ConfigNode,
-                          overridepath: ConfPath):
-        # The default ConfigOption simply overrides all of its sub-options, but
-        # this function is overridden by specific subclasses.
-        if overridecfg.sub is None:
-            return  # No sub-options, so nothing to override
-        for name, subopt in self.sub.items():
-            assert isinstance(selfcfg, ConfigNode)
-            assert isinstance(overridecfg, ConfigNode)
-            if name not in overridecfg.sub:
-                continue
-            subselfcfg = selfcfg.setdefault((name, ), ConfigNode())
-            subpath = selfpth + (name, )
-            suboverridepath = overridepath + (name, )
-            suboverridecfg = overridecfg.sub[name]
-            subopt.explicit_override(rootopts, subselfcfg, subpath,
-                                     suboverridecfg, suboverridepath)
-        if self.inherit_from is not None:
-            superopt = rootopts[self.inherit_from]
-            superopt.explicit_override(rootopts, selfcfg, selfpth, overridecfg,
-                                       overridepath)
-
-    def override(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-                 selfpath: ConfPath):
-        """Override other options with this option if appropriate. This is a 
-        no-op in most cases and only does something in OverrideConfigOption."""
-        assert cfg.contains(selfpath)
-
-    def verify_impl(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-                    cfgpath: ConfPath):
-        assert cfg.contains(cfgpath)
-        selfcfg = cfg[cfgpath]
-        # Check if there are any unknown options in the config
-        if not self.allow_unknown_keys:
-            unknwn = set(selfcfg.sub or ()) - set(self.sub or ())
-            if unknwn:
-                raise ConfigError(f'Unkown options in {pth2str(cfgpath)}: ' +
-                                  ', '.join(unknwn))
-        # Recursively verify the sub-options
-        if selfcfg.sub:
-            for name, sub in selfcfg.sub.items():
-                if name in self.sub:
-                    self.sub[name].verify(rootopts, cfg, cfgpath + (name, ))
-
-    def verify(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-               cfgpath: ConfPath):
-        if self.inherit_from is None:
-            return self.verify_impl(rootopts, cfg, cfgpath)
-        else:
-            return rootopts[self.inherit_from].verify_impl(
-                rootopts, cfg, cfgpath)
-
-    def override_all(self, cfg: ConfigNode):
-        # This is just me being lazy, we probably don't need to iterate over
-        # all nodes ...
-        for p, opt in self.iter_dfs():
-            if cfg.contains(p):
-                opt.override(self, cfg, p)
-
-    def verify_all(self, cfg: ConfigNode):
-        self.verify(self, cfg, ())
-
-    def inherit_all(self, cfg: ConfigNode):
-        self.inherit(self, cfg, ())
-
-    def update_default(
-            self,
-            rootopts: 'ConfigOption',
-            cfg: ConfigNode,
-            cfgpath: ConfPath,
-            selfpath: Optional[ConfPath] = None
-    ) -> Optional[DefaultValueWrapper]:
-        if selfpath is None:
-            selfpath = cfgpath
-
-        result = None
-        # If the entire path exists in cfg, simply return that value
-        cfgval = cfg.get(cfgpath)
-        if cfgval is not None:
-            result = cfgval
-        # If the path is not yet in cfg
-        else:
-            assert self is rootopts[selfpath]
-            # Find the default value for this option
-            default = self.default.get_default(rootopts, self, cfg, cfgpath,
-                                               selfpath)
-            # If the parent is set in the config, set this value as well
-            if default is not None and cfg.contains(parent(cfgpath)):
-                cfgval = cfg.setdefault(cfgpath, ConfigNode())
-                cfgval.value = default.value
-                if cfgval.value is not None:
-                    self.verify(rootopts, cfg, cfgpath)
-            result = default
-
-        if self.inherit_from is not None:
-            targetopt = rootopts.get(self.inherit_from)
-            if targetopt is None:
-                raise ValueError(f"Inheritance {pth2str(selfpath)} targets "
-                                 f"nonexisting option "
-                                 f"{pth2str(self.inherit_from)}")
-            for p, opt in targetopt.iter_dfs():
-                if opt.inherit_from is not None:
-                    # TODO: this might be too restrictive, but we need to break
-                    # the recursion somehow ...
-                    continue
-                optpth = joinpth(self.inherit_from, p)
-                newcfgpth = joinpth(cfgpath, p)
-                opt.update_default(rootopts, cfg, newcfgpth, optpth)
-
-        return result
-
-    def update_default_all(self, cfg: ConfigNode):
-        for p, opt in self.iter_dfs():
-            if hasparent(p) and cfg.contains(parent(p)):
-                opt.update_default(self, cfg, p)
-
-
-class UncheckedConfigOption(ConfigOption):
-
-    allow_unknown_keys = True
-
-
-class StrConfigOption(ConfigOption):
-
-    def get_typename(self, md: bool = False):
-        return 'string'
-
-    def explicit_override(self, opts: 'ConfigOption', selfcfg: ConfigNode,
-                          selfpth: ConfPath, overridecfg: ConfigNode,
-                          overridepath: ConfPath):
-        assert not self.sub
-        assert not selfcfg.sub
-        assert not overridecfg.sub
-        selfcfg.value = deepcopy(overridecfg.value)
-
-    def verify(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-               cfgpath: ConfPath):
-        if cfg[cfgpath].sub:
-            raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                              f'{str}, not {dict}')
-        elif not isinstance(cfg[cfgpath].value, str):
-            raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                              f'{str}, not {type(cfg[cfgpath].value)}')
-
-class EnumConfigOption(ConfigOption):
-
-    def __init__(self,
-                 name: str,
-                 description: str = '',
-                 example: str = '',
-                 default: DefaultValue = NoDefaultValue(),
-                 inherit_from: Optional[ConfPath] = None,
-                 create_if_inheritance_target_exists: bool = False,
-                 options: List[str] = []) -> None:
-        super().__init__(name, description, example, default, inherit_from, create_if_inheritance_target_exists)
-        self.options = options
-
-    def get_typename(self, md: bool = False):
-        if md:
-            return "`'" + "'` \| `'".join(self.options) + "'`"
-        else:
-            return "'" + "' | '".join(self.options) + "'"
-
-    def explicit_override(self, opts: 'ConfigOption', selfcfg: ConfigNode,
-                          selfpth: ConfPath, overridecfg: ConfigNode,
-                          overridepath: ConfPath):
-        assert not self.sub
-        assert not selfcfg.sub
-        assert not overridecfg.sub
-        selfcfg.value = deepcopy(overridecfg.value)
-
-    def verify(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-               cfgpath: ConfPath):
-        if cfg[cfgpath].sub:
-            raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                              f'{str}, not {dict}')
-        elif not isinstance(cfg[cfgpath].value, str):
-            raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                              f'{str}, not {type(cfg[cfgpath].value)}')
-        if cfg[cfgpath].value not in self.options:
-            raise ConfigError(f'Value of {pth2str(cfgpath)} should be '
-                              'one of \'' + "', '".join(self.options) + '\'')
-
-class BoolConfigOption(ConfigOption):
-
-    def get_typename(self, md: bool = False):
-        return 'bool'
-
-    def explicit_override(self, opts: 'ConfigOption', selfcfg: ConfigNode,
-                          selfpth: ConfPath, overridecfg: ConfigNode,
-                          overridepath: ConfPath):
-        assert not self.sub
-        assert not selfcfg.sub
-        assert not overridecfg.sub
-        selfcfg.value = deepcopy(overridecfg.value)
-
-    def verify(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-               cfgpath: ConfPath):
-        if cfg[cfgpath].sub:
-            raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                              f'{bool}, not {dict}')
-        elif not isinstance(cfg[cfgpath].value, bool):
-            raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                              f'{bool}, not {type(cfg[cfgpath].value)}')
-
-
-@dataclass
-class RelativeToCurrentConfig:
-    project_path: Path
-    description: str = 'current configuration file'
-
-
-@dataclass
-class RelativeToProject:
-    project_path: Path
-    description: str = 'project directory'
-
-
-class PathConfigOption(StrConfigOption):
-
-    def __init__(self,
-                 name: str,
-                 description: str = '',
-                 example: str = '',
-                 default: DefaultValue = NoDefaultValue(),
-                 must_exist: bool = True,
-                 expected_contents: List[str] = [],
-                 base_path: Optional[Union[RelativeToProject,
-                                           RelativeToCurrentConfig]] = None,
-                 allow_abs: bool = False,
-                 is_folder: bool = True):
-        super().__init__(name, description, example, default)
-        self.must_exist = must_exist or bool(expected_contents)
-        self.expected_contents = expected_contents
-        self.base_path = base_path
-        self.allow_abs = allow_abs
-        self.is_folder = is_folder
-        if self.base_path:
-            assert os.path.isabs(self.base_path.project_path)
-
-    def get_typename(self, md: bool = False):
-        return 'path' if self.is_folder else 'filepath'
-
-    def check_path(self, cfg: ConfigNode, cfgpath):
-        osp = os.path
-        path = osp.normpath(cfg[cfgpath].value)
-        # Absolute or relative path?
-        if osp.isabs(path):
-            # Absolute path
-            if not self.allow_abs:
-                raise ConfigError(f'{pth2str(cfgpath)}: "{str(path)}" '
-                                  f'must be a relative path')
-        else:
-            # Relative path
-            if isinstance(self.base_path, RelativeToCurrentConfig):
-                # cfgpath[0] is relative for files inside of the project,
-                # otherwise it is absolute
-                path = osp.join(osp.dirname(cfgpath[0]), path)
-                if not osp.isabs(path):
-                    path = osp.join(self.base_path.project_path, path)
-            elif isinstance(self.base_path, RelativeToProject):
-                path = osp.join(self.base_path.project_path, path)
-            else:
-                assert False, "Invalid relative path type"
-        assert osp.isabs(path), "Failed to make path absolute"
-        # Does the path exist?
-        if self.must_exist:
-            if not osp.exists(path):
-                raise ConfigError(f'{pth2str(cfgpath)}: "{str(path)}" '
-                                  f'does not exist')
-            if self.is_folder != osp.isdir(path):
-                type_ = 'directory' if self.is_folder else 'file'
-                raise ConfigError(f'{pth2str(cfgpath)}: "{str(path)}" '
-                                  f'should be a {type_}')
-            # Are any of the required contents missing?
-            missing = [
-                sub for sub in self.expected_contents
-                if not osp.exists(osp.join(path, sub))
-            ]
-            if missing:
-                missingstr = '", "'.join(missing)
-                raise ConfigError(f'{pth2str(cfgpath)}: "{str(path)}" '
-                                  f'does not contain the following '
-                                  f'required files or folders: "{missingstr}"')
-        cfg[cfgpath].value = osp.normpath(path)
-
-    def verify(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-               cfgpath: ConfPath):
-        super().verify(rootopts, cfg, cfgpath)
-        self.check_path(cfg, cfgpath)
-
-
-class ListOfStrConfigOption(ConfigOption):
-
-    def __init__(self,
-                 name: str,
-                 description: str = '',
-                 example: str = '',
-                 default: DefaultValue = NoDefaultValue(),
-                 inherit_from: Optional[ConfPath] = None,
-                 create_if_inheritance_target_exists: bool = False,
-                 convert_str_to_singleton=False) -> None:
-        super().__init__(name, description, example, default, inherit_from,
-                         create_if_inheritance_target_exists)
-        self.convert_str_to_singleton = convert_str_to_singleton
-
-    def get_typename(self, md: bool = False):
-        return 'list'
-
-    def explicit_override(self, opts: 'ConfigOption', selfcfg: ConfigNode,
-                          selfpth: ConfPath, overridecfg: ConfigNode,
-                          overridepath: ConfPath):
-        assert not self.sub
-        assert not selfcfg.sub
-        assert not overridecfg.sub
-        if overridecfg.value is not None:
-            if selfcfg.value is None:
-                selfcfg.value = []
-            assert isinstance(selfcfg.value, list)
-            assert isinstance(overridecfg.value, list)
-            selfcfg.value += deepcopy(overridecfg.value)
-
-    def verify(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-               cfgpath: ConfPath):
-        if cfg[cfgpath].sub:
-            raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                              f'{list}, not {dict}')
-        elif not isinstance(cfg[cfgpath].value, list):
-            if self.convert_str_to_singleton and \
-                    isinstance(cfg[cfgpath].value, str):
-                cfg[cfgpath].value = [cfg[cfgpath].value]
-            else:
-                raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                                  f'{list}, not {type(cfg[cfgpath].value)}')
-        elif not all(isinstance(el, str) for el in cfg[cfgpath].value):
-            raise ConfigError(f'Type of elements in {pth2str(cfgpath)} should '
-                              f'be {str}')
-
-
-class DictOfStrConfigOption(ConfigOption):
-
-    def get_typename(self, md: bool = False):
-        return 'dict'
-
-    def explicit_override(self, opts: 'ConfigOption', selfcfg: ConfigNode,
-                          selfpth: ConfPath, overridecfg: ConfigNode,
-                          overridepath: ConfPath):
-        assert not self.sub
-        assert not selfcfg.value
-        assert not overridecfg.value
-        if overridecfg.sub is not None:
-            if selfcfg.sub is None:
-                selfcfg.sub = {}
-            assert isinstance(selfcfg.sub, dict)
-            assert isinstance(overridecfg.sub, dict)
-            selfcfg.sub.update(deepcopy(overridecfg.sub))
-
-    def verify(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-               cfgpath: ConfPath):
-        if cfg[cfgpath].value is not None:
-            if isinstance(cfg[cfgpath].value, dict):
-                newcfg = ConfigNode.from_dict(cfg[cfgpath].value)
-                cfg[cfgpath].value = newcfg.value
-                cfg[cfgpath].sub = newcfg.sub
-            else:
-                raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                                  f'{dict}, not {type(cfg[cfgpath].value)}')
-        valdict = cfg[cfgpath].sub
-        if not isinstance(valdict, dict):
-            raise ConfigError(f'Type of {pth2str(cfgpath)} should be '
-                              f'{dict}, not {type(valdict)}')
-        elif not all(isinstance(el, str) for el in valdict.keys()):
-            raise ConfigError(f'Type of keys in {pth2str(cfgpath)} should '
-                              f'be {str}')
-        elif not all(isinstance(el.value, str) for el in valdict.values()):
-            raise ConfigError(f'Type of values in {pth2str(cfgpath)} should '
-                              f'be {str}')
-
-
-class OverrideConfigOption(ConfigOption):
-
-    def __init__(
-        self,
-        name: str,
-        description: str,
-        targetpath: ConfPath,
-        default: DefaultValue = NoDefaultValue()) -> None:
-        super().__init__(name, description, '', default)
-        self.targetpath = targetpath
-
-    def verify(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-               cfgpath: ConfPath):
-        rootopts[self.targetpath].verify(rootopts, cfg, cfgpath)
-
-    def inherit(self, rootopts: 'ConfigOption', cfg: ConfigNode,
-                selfpth: ConfPath):
-        pass
-
-    def override(self, rootopts: ConfigOption, cfg: ConfigNode,
-                 cfgpath: ConfPath):
-        selfcfg = cfg.get(cfgpath, None)
-        if selfcfg is None:
-            return
-        elif selfcfg.value is None and selfcfg.sub is None:
-            return
-        super().override(rootopts, cfg, cfgpath)
-        curropt = rootopts[self.targetpath]
-        self.create_parent_config(cfg, self.targetpath)
-        currcfg = cfg[self.targetpath]
-        overridecfg = cfg[cfgpath]
-        # Override the config at those paths by our own config
-        curropt.explicit_override(rootopts, currcfg, self.targetpath,
-                                  overridecfg, cfgpath)
-
-    @staticmethod
-    def create_parent_config(cfg: ConfigNode, path: ConfPath):
-        parentcfg = cfg
-        for s in path:
-            assert parentcfg.sub is not None
-            parentcfg = parentcfg.sub.setdefault(s, ConfigNode(sub={}))
diff --git a/src/py_build_cmake/datastructures.py b/src/py_build_cmake/datastructures.py
deleted file mode 100644
index 5816cf9..0000000
--- a/src/py_build_cmake/datastructures.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass
-class PackageInfo:
-    version: str
-    package_name: str
-    module_name: str
-
-
-@dataclass
-class BuildPaths:
-    source_dir: Path
-    wheel_dir: Path
-    temp_dir: Path
-    staging_dir: Path
-    pkg_staging_dir: Path
\ No newline at end of file
diff --git a/src/py_build_cmake/export/__init__.py b/src/py_build_cmake/export/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/py_build_cmake/export/editable/__init__.py b/src/py_build_cmake/export/editable/__init__.py
new file mode 100644
index 0000000..ec234e2
--- /dev/null
+++ b/src/py_build_cmake/export/editable/__init__.py
@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from ...common import BuildPaths, Config, Module
+from ...common.util import get_os_name
+from .hook import write_editable_hook
+from .symlink import write_editable_links
+from .wrapper import write_editable_wrapper
+
+
+def do_editable_install(cfg: Config, paths: BuildPaths, module: Module):
+    edit_cfg = cfg.editable["cross" if cfg.cross else get_os_name()]
+    mode = edit_cfg["mode"]
+    if mode == "wrapper":
+        write_editable_wrapper(paths.staging_dir, module)
+    elif mode == "hook":
+        write_editable_hook(paths.staging_dir, module)
+    elif mode == "symlink":
+        paths = write_editable_links(paths, module)
+    else:
+        msg = "Invalid editable mode"
+        raise AssertionError(msg)
+    return paths
diff --git a/src/py_build_cmake/export/editable/build_hook.py b/src/py_build_cmake/export/editable/build_hook.py
new file mode 100644
index 0000000..576fa66
--- /dev/null
+++ b/src/py_build_cmake/export/editable/build_hook.py
@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import logging
+import textwrap
+from pathlib import Path
+
+from ...commands.cmake import CMaker
+from ...common import Config, Module
+from ...common.util import get_os_name
+
+logger = logging.getLogger(__name__)
+
+
+def write_build_hook(
+    cfg: Config, staging_dir: Path, module: Module, cmaker: CMaker, idx: int
+):
+    """Write a hook that re-compiles extension modules."""
+    edit_cfg = cfg.editable["cross" if cfg.cross else get_os_name()]
+    if not edit_cfg.get("build_hook"):
+        return
+    if edit_cfg.get("mode") != "symlink":
+        logger.warning("Skipping build_hook: only supported for symlink mode")
+        return
+    name = module.name
+    fname = name + "_build_hook"
+    if idx != 0:
+        fname += f"_{idx}"
+    pkg_hook = staging_dir / fname
+    pkg_hook.mkdir(parents=True, exist_ok=True)
+    cwd = cmaker.get_working_dir()
+    env = cmaker.conf_settings.environment or {}
+    cmd = list(cmaker.get_build_commands()) + list(cmaker.get_install_commands())
+    content = f"""\
+        import sys, inspect, os
+        from importlib.machinery import PathFinder
+        from string import Template
+        import subprocess
+
+        class BuilderPathFinder(PathFinder):
+            def __init__(self, name, cwd, env, cmd):
+                self.name = name
+                self.cwd = cwd
+                self.env = env
+                self.cmd = cmd
+            def find_spec(self, name, path=None, target=None):
+                if name.split('.', 1)[0] == self.name:
+                    self.build()
+                return None
+            def prepare_environment(self):
+                env = os.environ.copy()
+                for k, v in self.env.items():
+                    templ = Template(v)
+                    env[k] = templ.substitute(env)
+                env["PY_BUILD_CMAKE_BUILD_HOOK"] = self.name
+                return env
+            def build(self):
+                # Prevent reentrant execution of the build hook
+                if "PY_BUILD_CMAKE_BUILD_HOOK" not in os.environ:
+                    env = self.prepare_environment()
+                    for cmd in self.cmd:
+                        try:
+                            subprocess.run(cmd, cwd=self.cwd, check=True, env=env)
+                        except subprocess.CalledProcessError as e:
+                            raise ImportError(
+                                f"Failed to build dependencies for module {{self.name!r}}",
+                                name=self.name,
+                                path=self.cwd,
+                            ) from e
+                sys.meta_path.remove(self)
+
+        def install(name: str, cwd, env, cmd):
+            sys.meta_path.insert(0, BuilderPathFinder(name, cwd, env, cmd))
+
+        install(
+            name={name!r},
+            cwd={cwd!r},
+            env={env!r},
+            cmd={cmd!r},
+        )
+        """
+    (pkg_hook / "__init__.py").write_text(textwrap.dedent(content), encoding="utf-8")
+    # Write a path file to find the development files
+    content = f"import {fname}\n"
+    with (staging_dir / f"{name}.pth").open("a") as f:
+        f.write(content)
diff --git a/src/py_build_cmake/export/editable/hook.py b/src/py_build_cmake/export/editable/hook.py
new file mode 100644
index 0000000..dd32d73
--- /dev/null
+++ b/src/py_build_cmake/export/editable/hook.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path
+
+from ...common import Module
+
+
+def write_editable_hook(staging_dir: Path, module: Module):
+    """Write a hook that finds the installed compiled extension modules."""
+    name = module.name
+    pkg_hook = staging_dir / (name + "_editable_hook")
+    pkg_hook.mkdir(parents=True, exist_ok=True)
+    content = f"""\
+        import sys, inspect, os
+        from importlib.machinery import PathFinder
+
+        class EditablePathFinder(PathFinder):
+            def __init__(self, name, extra_path):
+                self.name = name
+                self.extra_path = extra_path
+            def find_spec(self, name, path=None, target=None):
+                if name.split('.', 1)[0] != self.name:
+                    return None
+                if path is None:
+                    path = []
+                path.append(self.extra_path)
+                return super().find_spec(name, path, target)
+
+        def install(name: str):
+            source_path = os.path.abspath(inspect.getsourcefile(EditablePathFinder))
+            source_dir = os.path.dirname(source_path)
+            installed_path = os.path.join(source_dir, '..', name)
+            sys.meta_path.insert(0, EditablePathFinder(name, installed_path))
+
+        install('{name}')
+        """
+    (pkg_hook / "__init__.py").write_text(textwrap.dedent(content), encoding="utf-8")
+    # Write a path file to find the development files
+    content = f"{module.full_path.parent!s}\n" f"import {name}_editable_hook\n"
+    (staging_dir / f"{name}.pth").write_text(textwrap.dedent(content))
diff --git a/src/py_build_cmake/export/editable/symlink.py b/src/py_build_cmake/export/editable/symlink.py
new file mode 100644
index 0000000..0bca220
--- /dev/null
+++ b/src/py_build_cmake/export/editable/symlink.py
@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import shutil
+from copy import copy
+
+from ...common import BuildPaths, Module
+from ..util import copy_pkg_source_to
+
+
+def write_editable_links(paths: BuildPaths, module: Module) -> BuildPaths:
+    paths = copy(paths)
+    cache_dir = paths.build_dir
+    cache_dir.mkdir(exist_ok=True, parents=True)
+    paths.staging_dir = cache_dir / "editable"
+    shutil.rmtree(paths.staging_dir, ignore_errors=True)
+    paths.staging_dir.mkdir()
+    copy_pkg_source_to(paths.staging_dir, module, symlink=True)
+    pth_file = paths.pkg_staging_dir / f"{module.name}.pth"
+    pth_file.parent.mkdir(exist_ok=True)
+    pth_file.write_text(f"{paths.staging_dir!s}\n")
+    return paths
diff --git a/src/py_build_cmake/export/editable/wrapper.py b/src/py_build_cmake/export/editable/wrapper.py
new file mode 100644
index 0000000..10a68ac
--- /dev/null
+++ b/src/py_build_cmake/export/editable/wrapper.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import shutil
+import textwrap
+from pathlib import Path
+
+from ...common import ConfigError, Module
+
+
+def write_editable_wrapper(staging_dir: Path, module: Module):
+    """Write a fake __init__.py file that points to the development folder."""
+    if not module.is_package:
+        msg = "Editable wrapper mode is not supported for stand-alone Python modules."
+        raise ConfigError(msg)
+    name = module.name
+    tmp_pkg = staging_dir / name
+    pkgpath = module.full_path
+    initpath = pkgpath / "__init__.py"
+    tmp_pkg.mkdir(parents=True, exist_ok=True)
+    special_dunders = [
+        "__builtins__",
+        "__cached__",
+        "__file__",
+        "__loader__",
+        "__name__",
+        "__package__",
+        "__path__",
+        "__spec__",
+    ]
+    content = f"""\
+        # First extend the search path with the development folder
+        __spec__.submodule_search_locations.insert(0, {str(pkgpath)!a})
+        # Now manually import the development __init__.py
+        from importlib import util as _util
+        _spec = _util.spec_from_file_location("{name}",
+                                                {str(initpath)!a})
+        _mod = _util.module_from_spec(_spec)
+        _spec.loader.exec_module(_mod)
+        # After importing, add its symbols to our global scope
+        _vars = _mod.__dict__.copy()
+        for _k in ['{"','".join(special_dunders)}']: _vars.pop(_k)
+        globals().update(_vars)
+        # Clean up
+        del _k, _spec, _mod, _vars, _util
+        """
+    (tmp_pkg / "__init__.py").write_text(textwrap.dedent(content), encoding="utf-8")
+    # Add the py.typed file if it exists, so mypy picks up the stubs for
+    # the C++ extensions
+    py_typed = module.full_path / "py.typed"
+    if py_typed.exists():
+        shutil.copy2(py_typed, tmp_pkg)
+    # Write a path file so IDEs find the correct files as well
+    (staging_dir / f"{name}.pth").write_text(f"{module.full_path.parent!s}\n")
diff --git a/src/py_build_cmake/export/metadata.py b/src/py_build_cmake/export/metadata.py
new file mode 100644
index 0000000..4f02a71
--- /dev/null
+++ b/src/py_build_cmake/export/metadata.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import logging
+import shutil
+from copy import copy
+from pathlib import Path
+
+from ..common import ComponentConfig, Config
+
+logger = logging.getLogger(__name__)
+
+
+def _write_entry_points(entrypoints: dict[str, dict[str, str]], fp):
+    """Write entry_points.txt from a two-level dict
+
+    Sorts on keys to ensure results are reproducible.
+
+    Based on flit_core.
+    """
+    for group_name in sorted(entrypoints):
+        fp.write(f"[{group_name}]\n")
+        group = entrypoints[group_name]
+        for name in sorted(group):
+            val = group[name]
+            fp.write(f"{name}={val}\n")
+        fp.write("\n")
+
+
+def write_entry_points(cfg: Config | ComponentConfig, distinfo_dir: Path):
+    entrypoints = copy(cfg.standard_metadata.entrypoints)
+    if cfg.standard_metadata.scripts:
+        entrypoints["console_scripts"] = cfg.standard_metadata.scripts
+    if cfg.standard_metadata.gui_scripts:
+        entrypoints["gui_scripts"] = cfg.standard_metadata.gui_scripts
+    with (distinfo_dir / "entry_points.txt").open("w", encoding="utf-8") as f:
+        _write_entry_points(entrypoints, f)
+
+
+def write_license_files(cfg: Config | ComponentConfig, distinfo_dir: Path):
+    """Write the LICENSE file from pyproject.toml to the distinfo
+    directory."""
+    license = cfg.standard_metadata.license
+    if not license:
+        return
+    if license.file:
+        shutil.copy2(license.file, distinfo_dir)
+    else:
+        with (distinfo_dir / "LICENSE").open("w", encoding="utf-8") as f:
+            f.write(license.text)
+
+
+def write_metadata(cfg: Config | ComponentConfig, distinfo_dir: Path):
+    metadata_path = distinfo_dir / "METADATA"
+    with metadata_path.open("w", encoding="utf-8") as f:
+        f.write(str(cfg.standard_metadata.as_rfc822()))
diff --git a/src/py_build_cmake/export/native_tags.py b/src/py_build_cmake/export/native_tags.py
new file mode 100644
index 0000000..6ddab1f
--- /dev/null
+++ b/src/py_build_cmake/export/native_tags.py
@@ -0,0 +1,165 @@
+"""
+distlib.wheel doesn't always return the correct tags, and packaging.tags
+returns all tags supported by the interpreter, not the tags that should be used
+for the generated wheels. Therefore the only option here is to write our own
+(kind of hacky) functions based on packaging.tags.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import re
+import sys
+import sysconfig
+from importlib.machinery import EXTENSION_SUFFIXES
+from typing import Dict, List, Mapping
+
+from distlib.util import (  # type: ignore[import-untyped]
+    get_platform as get_platform_dashes,
+)
+from packaging import tags
+
+from ..common.util import archflags_to_platform_tag, platform_to_platform_tag
+
+_INTERPRETER_SHORT_NAMES: dict[str, str] = {
+    "python": "py",
+    "cpython": "cp",
+    "pypy": "pp",
+    "ironpython": "ip",
+    "jython": "jy",
+}
+
+
+def get_platform_tag() -> str:
+    return platform_to_platform_tag(get_platform_dashes())
+
+
+def get_interpreter_name() -> str:
+    name = sys.implementation.name
+    return _INTERPRETER_SHORT_NAMES.get(name) or name
+
+
+def get_interpreter_version() -> str:
+    return "".join(map(str, sys.version_info[:2]))
+
+
+def get_cpython_interpreter() -> str:
+    return f"cp{get_interpreter_version()}"
+
+
+def get_cpython_abi() -> str:
+    """
+    Get the ABI string for CPython, e.g. cp37m.
+
+    https://github.com/pypa/packaging/blob/917612f5774571a99902b5fe04d06099b9e8b667/packaging/tags.py#L135
+    """
+    py_version = sys.version_info[:2]
+    debug = pymalloc = ""
+    with_debug = sysconfig.get_config_var("Py_DEBUG")
+    has_refcount = hasattr(sys, "gettotalrefcount")
+    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
+    # extension modules is the best option.
+    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
+    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
+    if with_debug or (with_debug is None and (has_refcount or has_ext)):
+        debug = "d"
+    if py_version < (3, 8):
+        with_pymalloc = sysconfig.get_config_var("WITH_PYMALLOC")
+        if with_pymalloc or with_pymalloc is None:
+            pymalloc = "m"
+    return f"{get_cpython_interpreter()}{debug}{pymalloc}"
+
+
+def get_generic_interpreter() -> str:
+    return f"{get_interpreter_name()}{get_interpreter_version()}"
+
+
+def get_generic_abi() -> str:
+    abi = sysconfig.get_config_var("SOABI") or "none"
+    return platform_to_platform_tag(abi)
+
+
+def get_python_tag() -> str:
+    if get_interpreter_name() == "cp":
+        return get_cpython_interpreter()
+    else:
+        return get_generic_interpreter()
+
+
+def get_abi_tag() -> str:
+    if get_interpreter_name() == "cp":
+        return get_cpython_abi()
+    else:
+        return get_generic_abi()
+
+
+def _guess_arch_mac(archflags: str | None) -> str | None:
+    """Returns 'arm64', 'x86_64' or 'universal2', depending on the value of the
+    ARCHFLAGS environment variable if set. Otherwise returns the architecture
+    obtained from platform.mac_ver(). Returns None if ARCHFLAGS was invalid."""
+    if archflags:
+        archs = list(re.findall(r"-arch +(\S+)", archflags))
+    else:
+        _, _, arch = platform.mac_ver()
+        archs = [arch]
+    return archflags_to_platform_tag(archs)
+
+
+def _guess_version_mac(target: str | None) -> tuple[int, int]:
+    """Returns the macOS version set by the MACOSX_DEPLOYMENT_TARGET environment
+    variable, otherwise returns the version from platform.mac_ver()."""
+    version_str = None
+    if target:
+        m = re.match(r"^(\d+\.\d+)", target)
+        if m:
+            version_str = m.group(1)
+    if not version_str:
+        version_str, _, _ = platform.mac_ver()
+    version_parts = version_str.split(".")
+    major = int(version_parts[0]) if len(version_parts) > 0 else 0
+    minor = int(version_parts[1]) if len(version_parts) > 1 else 0
+    return major, minor
+
+
+def _guess_platform_tag_mac(env: Mapping[str, str] | None = None) -> str | None:
+    """Return an appropriate platform tag based on the ARCHFLAGS and
+    MACOSX_DEPLOYMENT_TARGET environment variables if set. Returns None if
+    neither was set, or if the platform tag could not be determined based on
+    their values."""
+    if env is None:
+        env = os.environ
+    archflags = env.get("ARCHFLAGS")
+    target = env.get("MACOSX_DEPLOYMENT_TARGET")
+    if not (archflags or target):
+        return None
+    arch = _guess_arch_mac(archflags)
+    if not arch:
+        return None
+    version = _guess_version_mac(target)
+    if arch == "arm64":
+        version = max(version, (11, 0))  # ARM64 is only supported on 11.0+
+    return f"macosx_{version[0]}_{version[1]}_{arch}"
+
+
+def guess_platform_tag(env=None) -> str:
+    if platform.system() == "Darwin":
+        plat = _guess_platform_tag_mac(env)
+        if plat:
+            return plat
+    try:
+        return next(tags.sys_tags()).platform
+    except StopIteration:
+        return get_platform_tag()
+
+
+WheelTags = Dict[str, List[str]]
+
+
+def get_native_tags(guess=False) -> WheelTags:
+    """Get the PEP 425 tags for the current platform."""
+    return {
+        "pyver": [get_python_tag()],
+        "abi": [get_abi_tag()],
+        "arch": [guess_platform_tag() if guess else get_platform_tag()],
+    }
diff --git a/src/py_build_cmake/export/sdist.py b/src/py_build_cmake/export/sdist.py
new file mode 100644
index 0000000..809aa07
--- /dev/null
+++ b/src/py_build_cmake/export/sdist.py
@@ -0,0 +1,244 @@
+"""
+The following functions and classes are based on flit_core, under the BSD 3-Clause license:
+
+Copyright (c) 2015, Thomas Kluyver and contributors
+All rights reserved.
+
+BSD 3-clause license:
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+import os
+import tarfile
+from copy import copy
+from gzip import GzipFile
+from pathlib import Path, PurePosixPath
+from typing import Iterable
+
+from pyproject_metadata import StandardMetadata
+
+from ..common import ConfigError, Module, PackageInfo
+
+logger = logging.getLogger(__name__)
+
+
+class SdistError(ConfigError):
+    """Problem packaging the project's sdist"""
+
+
+def normalize_file_permissions(st_mode):
+    """Normalize the permission bits in the st_mode field from stat to 644/755
+
+    Popular VCSs only track whether a file is executable or not. The exact
+    permissions can vary on systems with different umasks. Normalising
+    to 644 (non executable) or 755 (executable) makes builds more reproducible.
+    """
+    # Set 644 permissions, leaving higher bits of st_mode unchanged
+    new_mode = (st_mode | 0o644) & ~0o133
+    if st_mode & 0o100:
+        new_mode |= 0o111  # Executable: 644 -> 755
+    return new_mode
+
+
+def clean_tarinfo(ti: tarfile.TarInfo, mtime=None) -> tarfile.TarInfo:
+    """Clean metadata from a TarInfo object to make it more reproducible.
+
+    - Set uid & gid to 0
+    - Set uname and gname to ""
+    - Normalise permissions to 644 or 755
+    - Set mtime if not None
+    """
+    ti = copy(ti)
+    ti.uid = 0
+    ti.gid = 0
+    ti.uname = ""
+    ti.gname = ""
+    ti.mode = normalize_file_permissions(ti.mode)
+    if mtime is not None:
+        ti.mtime = mtime
+    return ti
+
+
+class FilePatterns:
+    """Manage a set of file inclusion/exclusion patterns relative to basedir"""
+
+    def __init__(self, patterns: Iterable[str], basedir: Path):
+        self.basedir = basedir
+
+        self.dirs = set()
+        self.files = set()
+
+        for pattern in patterns:
+            for path in sorted(basedir.glob(pattern)):
+                rel = path.relative_to(basedir)
+                if path.is_dir():
+                    self.dirs.add(rel)
+                else:
+                    self.files.add(rel)
+
+    def match_file(self, rel_path: Path) -> bool:
+        if rel_path in self.files:
+            return True
+
+        # Check if it's contained in any directory in the list
+        return any(d in rel_path.parents for d in self.dirs)
+
+    def match_dir(self, rel_path: Path) -> bool:
+        if rel_path in self.dirs:
+            return True
+
+        # Check if it's a subdirectory of any directory in the list
+        return any(d in rel_path.parents for d in self.dirs)
+
+
+class SdistBuilder:
+    """Builds a minimal sdist
+
+    These minimal sdists should work for PEP 517.
+    The class is extended in flit.sdist to make a more 'full fat' sdist,
+    which is what should normally be published to PyPI.
+    """
+
+    def __init__(
+        self,
+        module: Module,
+        pkg_info: PackageInfo,
+        metadata: StandardMetadata,
+        cfgdir: Path,
+        extra_files,
+        include_patterns: Iterable[str] = (),
+        exclude_patterns: Iterable[str] = (),
+    ):
+        self.module = module
+        self.pkg_info = pkg_info
+        self.metadata = metadata
+        self.cfgdir = cfgdir
+        self.extra_files = extra_files
+        self.includes = FilePatterns(include_patterns, cfgdir)
+        self.excludes = FilePatterns(exclude_patterns, cfgdir)
+
+    def select_files(self):
+        """Pick which files from the source tree will be included in the sdist
+
+        This is overridden in flit itself to use information from a VCS to
+        include tests, docs, etc. for a 'gold standard' sdist.
+        """
+        make_rel = lambda p: p.relative_to(self.module.base_path)
+        yield from map(make_rel, self.module.iter_files_abs())
+        yield from map(make_rel, self.extra_files)
+
+    def crucial_files(self):
+        make_rel = lambda p: p.relative_to(self.module.base_path)
+        if not self.module.is_generated and not self.module.is_namespace:
+            yield make_rel(self.module.full_file)
+        yield from map(make_rel, self.extra_files)
+
+    def apply_includes_excludes(self, files: Iterable[Path]):
+        files = {f for f in files if not self.excludes.match_file(f)}
+
+        for f_rel in self.includes.files:
+            if not self.excludes.match_file(f_rel):
+                files.add(Path(f_rel))
+
+        for rel_d in self.includes.dirs:
+            for dirpath, dirs, dfiles in os.walk(self.cfgdir / rel_d):
+                file: str
+                for file in dfiles:
+                    f_abs = Path(dirpath) / file
+                    f_rel = f_abs.relative_to(self.cfgdir)
+                    if not self.excludes.match_file(f_rel):
+                        files.add(f_rel)
+
+                # Filter subdirectories before os.walk scans them
+                dirs[:] = [
+                    d
+                    for d in dirs
+                    if not self.excludes.match_dir(
+                        (Path(dirpath) / d).relative_to(self.cfgdir)
+                    )
+                ]
+
+        crucial_files = set(self.crucial_files())
+        missing_crucial = crucial_files - files
+        if missing_crucial:
+            msg = f"Crucial files were excluded from the sdist: {', '.join(map(str, missing_crucial))}"
+            raise SdistError(msg)
+
+        return sorted(files)
+
+    def add_setup_py(self, files_to_add, target_tarfile):
+        """No-op here; overridden in flit to generate setup.py"""
+
+    @property
+    def dir_name(self):
+        return f"{self.pkg_info.norm_name}-{self.pkg_info.version}"
+
+    def build(self, target_dir: Path, gen_setup_py=True):
+        target_dir.mkdir(parents=True, exist_ok=True)
+        target = target_dir / (self.dir_name + ".tar.gz")
+        source_date_epoch = os.environ.get("SOURCE_DATE_EPOCH", "")
+        mtime = int(source_date_epoch) if source_date_epoch else None
+        gz = GzipFile(str(target), mode="wb", mtime=mtime)
+        tf = tarfile.TarFile(
+            str(target), mode="w", fileobj=gz, format=tarfile.PAX_FORMAT
+        )
+
+        try:
+            files_to_add = self.apply_includes_excludes(self.select_files())
+            archive_dir = PurePosixPath(self.dir_name)
+            for relpath in files_to_add:
+                path = self.cfgdir / relpath
+                archive_path = archive_dir / PurePosixPath(relpath)
+                ti = tf.gettarinfo(path, arcname=str(archive_path))
+                ti = clean_tarinfo(ti, mtime)
+
+                if ti.isreg():
+                    with path.open("rb") as f:
+                        tf.addfile(ti, f)
+                else:
+                    tf.addfile(ti)  # Symlinks & ?
+
+            if gen_setup_py:
+                self.add_setup_py(files_to_add, tf)
+
+            stream = io.StringIO()
+            stream.write(str(self.metadata.as_rfc822()))
+            pkg_info = stream.getvalue().encode()
+            ti = tarfile.TarInfo(str(archive_dir / "PKG-INFO"))
+            ti.size = len(pkg_info)
+            tf.addfile(ti, io.BytesIO(pkg_info))
+
+        finally:
+            tf.close()
+            gz.close()
+
+        logger.debug("Built sdist: %s", target)
+        return target
diff --git a/src/py_build_cmake/export/tags.py b/src/py_build_cmake/export/tags.py
new file mode 100644
index 0000000..bbf0515
--- /dev/null
+++ b/src/py_build_cmake/export/tags.py
@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import re
+from copy import copy
+from typing import Any
+
+from .native_tags import WheelTags, get_native_tags
+
+
+def get_cross_tags(crosscfg: dict[str, Any]) -> WheelTags:
+    """Get the PEP 425 tags to use when cross-compiling."""
+    tags = get_native_tags()
+    if "implementation" in crosscfg and "version" in crosscfg:
+        tags["pyver"] = [crosscfg["implementation"] + crosscfg["version"]]
+    if "abi" in crosscfg:
+        tags["abi"] = [crosscfg["abi"]]
+    if "arch" in crosscfg:
+        tags["arch"] = [crosscfg["arch"]]
+    return tags
+
+
+def convert_abi_tag(abi_tag: str, wheel_cfg: dict) -> str:
+    """Set the ABI tag to 'none' or 'abi3', depending on the config options
+    specified by the user."""
+    if wheel_cfg["python_abi"] == "auto":
+        return abi_tag
+    elif wheel_cfg["python_abi"] == "none":
+        return "none"
+    elif wheel_cfg["python_abi"] == "abi3":
+        # Only use abi3 if we're actually building for CPython
+        m = re.match(r"^cp(\d+).*$", abi_tag)
+        if m and int(m[1]) >= wheel_cfg["abi3_minimum_cpython_version"]:
+            return "abi3"
+        return abi_tag
+    else:
+        msg = "Unsupported python_abi"
+        raise AssertionError(msg)
+
+
+def convert_wheel_tags(tags: dict[str, list[str]], wheel_cfg: dict) -> WheelTags:
+    """Apply convert_abi_tag to each of the abi tags and override any tags
+    that were specified in the config file."""
+    tags = copy(tags)
+    cvt_abi = lambda tag: convert_abi_tag(tag, wheel_cfg)
+    tags["abi"] = list(map(cvt_abi, tags["abi"]))
+    if wheel_cfg["python_tag"] != ["auto"]:
+        pyver = tags["pyver"][0]
+        pyver_cfg = wheel_cfg["python_tag"]
+        tags["pyver"] = [pyver if v == "auto" else v for v in pyver_cfg]
+        tags["pyver"] = list(dict.fromkeys(tags["pyver"]))  # unique tags
+    if "abi_tag" in wheel_cfg:
+        tags["abi"] = wheel_cfg["abi_tag"]
+    if "platform_tag" in wheel_cfg:
+        plat = wheel_cfg["platform_tag"]  # Platform tags specified by the user
+        guess = tags["arch"]  # Tags guessed based on the current interpreter
+        # If the user-specified tags contain "guess", replace it by the guesses
+        tags["arch"] = [x for t in plat for x in (guess if t == "guess" else [t])]
+    return tags
+
+
+def is_pure(wheel_cfg: dict, cmake_cfg: dict | None) -> bool:
+    """Check if the package is a pure-Python package without platform-
+    specific binaries."""
+    if "pure_python" in wheel_cfg:
+        return wheel_cfg["pure_python"]
+    return not cmake_cfg
diff --git a/src/py_build_cmake/export/util.py b/src/py_build_cmake/export/util.py
new file mode 100644
index 0000000..a36613c
--- /dev/null
+++ b/src/py_build_cmake/export/util.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from ..common import Module
+
+
+def copy_pkg_source_to(staging_dir: Path, module: Module, symlink: bool = False):
+    """Copy the files of a Python package to the build directory."""
+    for src in module.iter_files_abs():
+        rel_path = src.relative_to(module.prefix)
+        dst = staging_dir / rel_path
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        if symlink:
+            dst.symlink_to(src, target_is_directory=False)
+        else:
+            shutil.copy2(src, dst, follow_symlinks=False)
diff --git a/src/py_build_cmake/export/wheel.py b/src/py_build_cmake/export/wheel.py
new file mode 100644
index 0000000..e0a5eef
--- /dev/null
+++ b/src/py_build_cmake/export/wheel.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import logging
+import os
+import time
+import zipfile
+from pathlib import Path
+
+from distlib.wheel import Wheel  # type: ignore[import-untyped]
+
+logger = logging.getLogger(__name__)
+
+
+class WheelBuilder(Wheel):
+    def _get_source_time(self):
+        """
+        Get the value of the SOURCE_DATE_EPOCH in a format to pass to ZipInfo.
+        https://reproducible-builds.org/docs/source-date-epoch/
+        """
+        if "SOURCE_DATE_EPOCH" not in os.environ:
+            return None
+        source_date_epoch = os.environ["SOURCE_DATE_EPOCH"]
+        try:
+            filetime = int(source_date_epoch)
+        except ValueError:
+            msg = "SOURCE_DATE_EPOCH is not an integer, so I'm ignoring it."
+            logger.warning(msg)
+            return None
+        return time.gmtime(max(315532800, filetime))
+
+    def build_zip(self, pathname: str | Path, archive_paths: list[tuple[str, str]]):
+        """
+        We override this method to ensure a consistent modification time for all
+        files in the ZIP if the SOURCE_DATE_EPOCH environment variable is set.
+        """
+        filetime = self._get_source_time()
+        if filetime is None:
+            super().build_zip(pathname, archive_paths)
+            return
+        tmstr = time.strftime("%Y-%m-%dT%H:%M:%S", filetime)
+        msg = f"SOURCE_DATE_EPOCH is set, using mtime={tmstr} for files in Wheel"
+        logger.info(msg)
+        with zipfile.ZipFile(pathname, "w", zipfile.ZIP_DEFLATED) as zf:
+            for ap, p in archive_paths:
+                file_zipinfo = zipfile.ZipInfo(ap, date_time=filetime)
+                zf.writestr(file_zipinfo, Path(p).read_bytes())
+                logger.debug("Wrote %s to %s in wheel", p, ap)
diff --git a/src/py_build_cmake/help.py b/src/py_build_cmake/help.py
new file mode 100644
index 0000000..325dc93
--- /dev/null
+++ b/src/py_build_cmake/help.py
@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import html
+import itertools
+import os
+import re
+import shutil
+import sys
+import textwrap
+
+from .config.options.config_option import ConfigOption, UncheckedConfigOption
+from .config.options.default import RequiredValue
+from .config.options.path import PathConfigOption
+
+
+def _print_wrapped(text: str, indent, width: int | None = None):
+    """Print the given string with the given indentation, wrapping it to the
+    desired width, preserving line endings. If `width` is None, use the width
+    of the terminal, or 80 columns as a fallback."""
+    if width is None:
+        width = shutil.get_terminal_size((80, 24)).columns
+    wrapper = textwrap.TextWrapper(
+        width=width, initial_indent=indent, subsequent_indent=indent
+    )
+    wrapped = [wrapper.wrap(i) for i in text.split("\n")]
+    for line in itertools.chain.from_iterable(wrapped):
+        print(line)
+
+
+def get_default_str(opt: ConfigOption):
+    """Get a string representation of the default value for the given option."""
+    return opt.default.get_name()
+
+
+def help_print_md(pbc_opts: ConfigOption):
+    """
+    Prints the top-level options in `pbc_opts` as MarkDown tables.
+    """
+    for k, v in pbc_opts.sub_options.items():
+        if not v.sub_options:
+            continue
+        print("##", k)
+        print(_get_full_description(v), "\n")
+        print("| Option | Description | Type | Default |")
+        print("|--------|-------------|------|---------|")
+        for kk, vv in v.sub_options.items() or {}:
+            typename = vv.get_typename(md=True) or ""
+            print(
+                "|",
+                f"`{kk}`",
+                "|",
+                _get_full_description(vv),
+                "|",
+                typename,
+                "|",
+                f"`{get_default_str(vv)}`",
+                "|",
+            )
+        print()
+
+
+def _get_full_description(vv: ConfigOption):
+    descr = _md_escape(vv.description)
+    if isinstance(vv, PathConfigOption):
+        descr += "<br/>" + _describe_path_option(vv).capitalize() + "."
+    if vv.inherits:
+        descr += "<br/>Inherits from: `/" + str(vv.inherits) + "`"
+    if vv.example:
+        descr += "<br/>For example: `" + vv.example + "`"
+    return descr
+
+
+def _md_escape(descr: str):
+    descr = html.escape(descr)
+    descr = descr.replace("*", "\\*")
+    descr = descr.replace("_", "\\_")
+
+    def unescape(m: re.Match):
+        m0 = m.group(0)
+        return html.unescape(m0.replace("\\_", "_").replace("\\*", "*"))
+
+    descr = re.sub(r"`.*`", unescape, descr)
+    return descr.replace("\n", "<br/>")
+
+
+def _should_use_colors():
+    # Check if output is a terminal
+    if not sys.stdout.isatty():
+        return False
+    # Check the NO_COLOR environment variable
+    if "NO_COLOR" in os.environ:
+        return False
+    # Check the TERM environment variable
+    term = os.environ.get("TERM", "")
+    if term == "dumb":
+        return False
+    # Check CLICOLOR and CLICOLOR_FORCE
+    clicolor = os.environ.get("CLICOLOR", "1")
+    clicolor_force = os.environ.get("CLICOLOR_FORCE", "0")
+    if clicolor == "0":
+        return False
+    if clicolor_force == "1":
+        return True
+    # Default to enabling colors
+    return True
+
+
+def _style(text: str, style: str):
+    if _should_use_colors():
+        return f"\x1b[{style}m{text}\x1b[0m"
+    else:
+        return text
+
+
+def recursive_help_print(opt: ConfigOption, level=0):
+    """Recursively prints the help messages for the options in `opt`."""
+    for k, v in opt.sub_options.items():
+        if isinstance(v, UncheckedConfigOption):
+            continue
+        indent = 4 * level * " "
+        header = "\n" + _style(k, "1;4")
+        if v.sub_options:
+            header += ":"
+            print(textwrap.indent(header, indent))
+            if v.description:
+                _print_wrapped(v.description, indent + "  ")
+            recursive_help_print(v, level + 1)
+        else:
+            headerfields = []
+            typename = v.get_typename()
+            if typename is not None:
+                headerfields += [_style(typename, "34")]
+            if isinstance(v, PathConfigOption):
+                headerfields += [_describe_path_option(v)]
+            is_required = isinstance(v.default, RequiredValue)
+            if is_required:
+                headerfields += [_style("required", "31")]
+            if v.inherits:
+                headerfields += [_style("inherits from /" + str(v.inherits), "3")]
+            if headerfields:
+                header += " (" + ", ".join(headerfields) + ")"
+            print(textwrap.indent(header + ":", indent))
+            _print_wrapped(v.description, indent + "  ")
+            if v.example:
+                _print_wrapped("For example: " + v.example, indent + "  ")
+            default = v.default.get_name()
+            if not is_required:
+                print(textwrap.indent("Default: " + default, indent + "  "))
+
+
+def _describe_path_option(v: PathConfigOption):
+    t = "absolute or relative" if v.allow_abs else "relative"
+    if v.base_path is not None:
+        t += " to " + v.base_path.description
+    return t
+
+
+def help_print(pbc_opts: ConfigOption):
+    recursive_help_print(pbc_opts)
+    print()
diff --git a/src/py_build_cmake/help/__init__.py b/src/py_build_cmake/help/__init__.py
deleted file mode 100644
index 4c5fd08..0000000
--- a/src/py_build_cmake/help/__init__.py
+++ /dev/null
@@ -1,112 +0,0 @@
-import html
-import itertools
-import shutil
-import textwrap
-import re
-
-from ..config_options import ConfigOption, PathConfigOption, RequiredValue, pth2str
-
-
-def _print_wrapped(text, indent, width=None):
-    """Print the given string with the given indentation, wrapping it to the
-    desired width, preserving line endings. If `width` is None, use the width 
-    of the terminal, or 80 columns as a fallback."""
-    if width is None:
-        width = shutil.get_terminal_size((80, 24)).columns
-    wrapper = textwrap.TextWrapper(width=width,
-                                   initial_indent=indent,
-                                   subsequent_indent=indent)
-    wrapped = [wrapper.wrap(i) for i in text.split('\n')]
-    for line in itertools.chain.from_iterable(wrapped):
-        print(line)
-
-
-def get_default_str(opt: ConfigOption):
-    """Get a string representation of the default value for the given option."""
-    return opt.default.get_name()
-
-
-def help_print_md(pbc_opts: ConfigOption):
-    """
-    Prints the top-level options in `pbc_opts` as MarkDown tables.
-    """
-    for k, v in pbc_opts.sub.items():
-        print('##', k)
-        print(_get_full_description(v), '\n')
-        print('| Option | Description | Type | Default |')
-        print('|--------|-------------|------|---------|')
-        for kk, vv in v.sub.items() or {}:
-            typename = vv.get_typename(md=True) or ''
-            print('|', f'`{kk}`', '|', _get_full_description(vv), '|',
-                  typename, '|', f'`{get_default_str(vv)}`', '|')
-        print()
-
-def _get_full_description(vv: ConfigOption):
-    descr = _md_escape(vv.description)
-    if isinstance(vv, PathConfigOption):
-        descr += '<br/>' + _describe_path_option(vv).capitalize() + '.'
-    if vv.inherit_from:
-        descr += '<br/>Inherits from: `/' + pth2str(vv.inherit_from) + '`'
-    if vv.example:
-        descr += '<br/>For example: `' + vv.example + '`'
-    return descr
-
-
-def _md_escape(descr: str):
-    descr = html.escape(descr)
-    descr = descr.replace('*', '\\*')
-    descr = descr.replace('_', '\\_')
-    def unescape(m: re.Match):
-        m0 = m.group(0)
-        return html.unescape(m0.replace('\\_', '_').replace('\\*', '*'))
-    descr = re.sub(r'`.*`', unescape, descr)
-    descr = descr.replace('\n', '<br/>')
-    return descr
-
-
-def recursive_help_print(opt: ConfigOption, level=0):
-    """Recursively prints the help messages for the options in `opt`."""
-    for k, v in opt.sub.items():
-        if k == 'project':
-            continue
-        indent = 4 * level * ' '
-        header = '\n' + k
-        if v.sub:
-            header += ':'
-            print(textwrap.indent(header, indent))
-            if v.description:
-                _print_wrapped(v.description, indent + '  ')
-            recursive_help_print(v, level + 1)
-        else:
-            headerfields = []
-            typename = v.get_typename()
-            if typename is not None:
-                headerfields += [typename]
-            if isinstance(v, PathConfigOption):
-                headerfields += [_describe_path_option(v)]
-            is_required = isinstance(v.default, RequiredValue)
-            if is_required:
-                headerfields += ['required']
-            if v.inherit_from:
-                headerfields += ['inherits from /' + pth2str(v.inherit_from)]
-            if headerfields:
-                header += ' (' + ', '.join(headerfields) + ')'
-            print(textwrap.indent(header + ':', indent))
-            _print_wrapped(v.description, indent + '  ')
-            if v.example:
-                _print_wrapped('For example: ' + v.example, indent + '  ')
-            default = v.default.get_name()
-            if default is not None and not is_required:
-                print(textwrap.indent('Default: ' + default, indent + '  '))
-
-
-def _describe_path_option(v: PathConfigOption):
-    t = 'absolute or relative' if v.allow_abs else 'relative'
-    if v.base_path is not None:
-        t += ' to ' + v.base_path.description
-    return t
-
-
-def help_print(pbc_opts: ConfigOption):
-    recursive_help_print(pbc_opts)
-    print()
diff --git a/src/py_build_cmake/help/__main__.py b/src/py_build_cmake/help/__main__.py
deleted file mode 100644
index 5f4a1ad..0000000
--- a/src/py_build_cmake/help/__main__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-def main():
-    print("py_build_cmake.help is deprecated, please "
-          "use py-build-cmake config format instead.")
-    exit(1)
-
-
-if __name__ == '__main__':
-    main()
\ No newline at end of file
diff --git a/src/py_build_cmake/pyproject_options.py b/src/py_build_cmake/pyproject_options.py
deleted file mode 100644
index dd4954a..0000000
--- a/src/py_build_cmake/pyproject_options.py
+++ /dev/null
@@ -1,394 +0,0 @@
-from .config_options import *
-
-
-def get_tool_pbc_path():
-    return pth('pyproject.toml/tool/py-build-cmake')
-
-
-def get_cross_path():
-    return pth('pyproject.toml/tool/py-build-cmake/cross')
-
-
-def get_options(project_path: Path, *, test: bool = False):
-    root = ConfigOption("root")
-    pyproject = root.insert(UncheckedConfigOption("pyproject.toml"))
-    project = pyproject.insert(UncheckedConfigOption('project'))
-    project.insert(UncheckedConfigOption('name', default=RequiredValue()))
-    name_pth = pth('pyproject.toml/project/name')
-    tool = pyproject.insert(
-        UncheckedConfigOption("tool",
-                              default=DefaultValueValue({}),
-                              create_if_inheritance_target_exists=True))
-    pbc = tool.insert(
-        ConfigOption("py-build-cmake",
-                     default=DefaultValueValue({}),
-                     create_if_inheritance_target_exists=True))
-
-    # [tool.py-build-cmake.module]
-    module = pbc.insert(
-        ConfigOption(
-            "module",
-            "Defines the import name of the module or package, and the "
-            "directory where it can be found.",
-            default=DefaultValueValue({}),
-        ))
-    pbc_pth = get_tool_pbc_path()
-    module.insert_multiple([
-        StrConfigOption('name',
-                        "Import name in Python (can be different from the "
-                        "name on PyPI, which is defined in the [project] "
-                        "section).",
-                        default=RefDefaultValue(name_pth)),
-        PathConfigOption('directory',
-                         "Directory containing the Python module/package.",
-                         default=DefaultValueValue("."),
-                         base_path=RelativeToProject(project_path),
-                         must_exist=not test),
-    ])
-
-    # [tool.py-build-cmake.editable]
-    editable = pbc.insert(
-        ConfigOption(
-            "editable",
-            "Defines how to perform an editable install (PEP 660). See "
-            "https://tttapa.github.io/py-build-cmake/Editable-install.html "
-            "for more information.",
-            default=DefaultValueValue({}),
-        ))
-    editable_pth = pth('pyproject.toml/tool/py-build-cmake/editable')
-    editable.insert_multiple([
-        EnumConfigOption('mode',
-                         "Mechanism to use for editable installations. "
-                         "Either write a wrapper __init__.py file, install an "
-                         "import hook, or install symlinks to the original "
-                         "files.",
-                         default=DefaultValueValue("wrapper"),
-                         options=["wrapper", "hook", "symlink"]),
-    ])
-
-    # [tool.py-build-cmake.sdist]
-    sdist = pbc.insert(
-        ConfigOption(
-            "sdist",
-            "Specifies the files that should be included in the source "
-            "distribution for this package.",
-            default=DefaultValueValue({}),
-            create_if_inheritance_target_exists=True,
-        ))
-    sdist_pth = pth('pyproject.toml/tool/py-build-cmake/sdist')
-    sdist.insert_multiple([
-        ListOfStrConfigOption('include',
-                              "Files and folders to include in the source "
-                              "distribution. May include the '*' wildcard "
-                              "(but not '**' for recursive patterns).",
-                              default=DefaultValueValue([])),
-        ListOfStrConfigOption('exclude',
-                              "Files and folders to exclude from the source "
-                              "distribution. May include the '*' wildcard "
-                              "(but not '**' for recursive patterns).",
-                              default=DefaultValueValue([])),
-    ])  # yapf: disable
-
-    # [tool.py-build-cmake.cmake]
-    cmake = pbc.insert(
-        ConfigOption(
-            "cmake",
-            "Defines how to build the project to package. If omitted, "
-            "py-build-cmake will produce a pure Python package.",
-        ))
-    cmake_pth = pth('pyproject.toml/tool/py-build-cmake/cmake')
-    cmake.insert_multiple([
-        StrConfigOption('minimum_version',
-                        "Minimum required CMake version. If this version is "
-                        "not available in the system PATH, it will be "
-                        "installed automatically as a build dependency.",
-                        "minimum_version = \"3.18\"",
-                        default=NoDefaultValue()),
-        StrConfigOption('build_type',
-                        "Build type passed to the configuration step, as "
-                        "`-DCMAKE_BUILD_TYPE=<?>`.",
-                        "build_type = \"RelWithDebInfo\""),
-        ListOfStrConfigOption('config',
-                              "Configuration type passed to the build and "
-                              "install steps, as `--config <?>`. You can "
-                              "specify either a single string, or a list of "
-                              "strings. If a multi-config generator is used, "
-                              "all configurations in this list will be "
-                              "included in the package.",
-                              "config = [\"Debug\", \"Release\"]",
-                              default=RefDefaultValue(pth('build_type'),
-                                                      relative=True),
-                              convert_str_to_singleton=True),
-        StrConfigOption('preset',
-                        "CMake preset to use for configuration. Passed as "
-                        "`--preset <?>` during the configuration phase."),
-        ListOfStrConfigOption('build_presets',
-                              "CMake presets to use for building. Passed as "
-                              "`--preset <?>` during the build phase, once "
-                              "for each preset.",
-                              default=RefDefaultValue(pth('preset'),
-                                                      relative=True),
-                              convert_str_to_singleton=True),
-        ListOfStrConfigOption('install_presets',
-                              "CMake presets to use for installing. Passed as "
-                              "`--preset <?>` during the installation phase, "
-                              "once for each preset.",
-                              default=RefDefaultValue(pth('build_presets'),
-                                                      relative=True),
-                              convert_str_to_singleton=True),
-        StrConfigOption('generator',
-                        "CMake generator to use, passed to the "
-                        "configuration step, as "
-                        "`-G <?>`. If Ninja is used, and if it is not "
-                        "available in the system PATH, it will be installed "
-                        "automatically as a build dependency.",
-                        "generator = \"Ninja Multi-Config\""),
-        PathConfigOption('source_path',
-                         "Folder containing CMakeLists.txt.",
-                         default=DefaultValueValue("."),
-                         expected_contents=[] if test else ["CMakeLists.txt"],
-                         base_path=RelativeToProject(project_path),
-                         must_exist=not test),
-        PathConfigOption('build_path',
-                         "CMake build and cache folder.",
-                         default=DefaultValueValue('.py-build-cmake_cache'),
-                         allow_abs=True,
-                         base_path=RelativeToProject(project_path),
-                         must_exist=False),
-        DictOfStrConfigOption('options',
-                              "Extra options passed to the configuration step, "
-                              "as `-D<option>=<value>`.",
-                              "options = {\"WITH_FEATURE_X\" = \"On\"}",
-                              default=DefaultValueValue({})),
-        ListOfStrConfigOption('args',
-                              "Extra arguments passed to the configuration "
-                              "step.",
-                              "args = [\"--debug-find\", \"-Wdev\"]",
-                              default=DefaultValueValue([])),
-        BoolConfigOption('find_python',
-                         "Specify hints for CMake's FindPython module.",
-                         "find_python = true",
-                         default=DefaultValueValue(False)),
-        BoolConfigOption('find_python3',
-                         "Specify hints for CMake's FindPython3 module.",
-                         "find_python3 = false",
-                         default=DefaultValueValue(True)),
-        ListOfStrConfigOption('build_args',
-                              "Extra arguments passed to the build step.",
-                              "build_args = [\"-j\", \"--target\", \"foo\"]",
-                              default=DefaultValueValue([])),
-        ListOfStrConfigOption('build_tool_args',
-                              "Extra arguments passed to the build tool in the "
-                              "build step (e.g. to Make or Ninja).",
-                              "build_tool_args = "
-                              "[\"--verbose\", \"-d\", \"explain\"]",
-                              default=DefaultValueValue([])),
-        ListOfStrConfigOption('install_args',
-                              "Extra arguments passed to the install step.",
-                              "install_args = [\"--strip\"]",
-                              default=DefaultValueValue([])),
-        ListOfStrConfigOption("install_components",
-                              "List of components to install, the install step "
-                              "is executed once for each component, with the "
-                              "option `--component <?>`.\n"
-                              "Use an empty string to specify the default "
-                              "component.",
-                              default=DefaultValueValue([""])),
-        DictOfStrConfigOption("env",
-                              "Environment variables to set when running "
-                              "CMake. Supports variable expansion using "
-                              "`${VAR}` (but not `$VAR`).",
-                              "env = { \"CMAKE_PREFIX_PATH\" "
-                              "= \"${HOME}/.local\" }",
-                              default=DefaultValueValue({})),
-    ])# yapf: disable
-
-    # [tool.py-build-cmake.stubgen]
-    stubgen = pbc.insert(
-        ConfigOption(
-            "stubgen",
-            "If specified, mypy's stubgen utility will be used to generate "
-            "typed stubs for the Python files in the package.",
-        ))
-    stubgen.insert_multiple([
-        ListOfStrConfigOption('packages',
-                              "List of packages to generate stubs for, passed "
-                              "to stubgen as -p <?>."),
-        ListOfStrConfigOption('modules',
-                              "List of modules to generate stubs for, passed "
-                              "to stubgen as -m <?>."),
-        ListOfStrConfigOption('files',
-                              "List of files to generate stubs for, passed to "
-                              "stubgen without any flags."),
-        ListOfStrConfigOption('args',
-                              "List of extra arguments passed to stubgen.",
-                              default=DefaultValueValue([])),
-    ]) # yapf: disable
-
-    # [tool.py-build-cmake.{linux,windows,mac}]
-    for system in ["Linux", "Windows", "Mac"]:
-        name = system.lower()
-        opt = pbc.insert(
-            ConfigOption(
-                name,
-                f"Override options for {system}.",
-                create_if_inheritance_target_exists=True,
-                default=DefaultValueValue({}),
-            ))
-        opt.insert_multiple([
-            ConfigOption("editable",
-                         f"{system}-specific editable options.",
-                         inherit_from=editable_pth,
-                         create_if_inheritance_target_exists=True),
-            ConfigOption("sdist",
-                         f"{system}-specific sdist options.",
-                         inherit_from=sdist_pth,
-                         create_if_inheritance_target_exists=True),
-            ConfigOption("cmake",
-                         f"{system}-specific CMake options.",
-                         inherit_from=cmake_pth,
-                         create_if_inheritance_target_exists=True),
-        ])
-
-    # [tool.py-build-cmake.cross]
-    cross = pbc.insert(
-        ConfigOption(
-            "cross",
-            "Causes py-build-cmake to cross-compile the project. See "
-            "https://tttapa.github.io/py-build-cmake/Cross-compilation.html "
-            "for more information.",
-        ))
-    cross_pth = get_cross_path()
-    cross.insert_multiple([
-        StrConfigOption('implementation',
-                        "Identifier for the Python implementation.",
-                        "implementation = 'cp' # CPython",
-                        default=NoDefaultValue('same as current interpreter')),
-        StrConfigOption('version',
-                        "Python version, major and minor, without dots.",
-                        "version = '310' # 3.10",
-                        default=NoDefaultValue('same as current interpreter')),
-        StrConfigOption('abi',
-                        "Python ABI.",
-                        "abi = 'cp310'",
-                        default=NoDefaultValue('same as current interpreter')),
-        StrConfigOption('arch',
-                        "Operating system and architecture (no dots or "
-                        "dashes, only underscores, all lowercase).",
-                        "arch = 'linux_x86_64'",
-                        default=NoDefaultValue('same as current interpreter')),
-        PathConfigOption('toolchain_file',
-                         "CMake toolchain file to use. See "
-                         "https://cmake.org/cmake/help/book/mastering-cmake"
-                         "/chapter/Cross%20Compiling%20With%20CMake.html for "
-                         "more information.",
-                         default=RequiredValue(),
-                         base_path=RelativeToCurrentConfig(project_path),
-                         must_exist=not test,
-                         allow_abs=True,
-                         is_folder=False),
-        ListOfStrConfigOption('copy_from_native_build',
-                              "If set, this will cause a native version of the "
-                              "CMake project to be built and installed in a "
-                              "temporary directory first, and the files in this "
-                              "list will be copied to the final cross-compiled "
-                              "package. This is useful if you need binary "
-                              "utilities that run on the build system while "
-                              "cross-compiling, or for things like stubs for "
-                              "extension modules that cannot be generated while "
-                              "cross-compiling.\n"
-                              "May include the '*' wildcard "
-                              "(but not '**' for recursive patterns)."),
-        ConfigOption("sdist",
-                     "Override sdist options when cross-compiling.",
-                     inherit_from=sdist_pth,
-                     create_if_inheritance_target_exists=True),
-        ConfigOption("cmake",
-                     "Override CMake options when cross-compiling.",
-                     inherit_from=cmake_pth,
-                     create_if_inheritance_target_exists=True),
-    ]) # yapf: disable
-
-    # local override
-    root.insert(
-        OverrideConfigOption("py-build-cmake.local.toml",
-                             "Allows you to override the "
-                             "settings in pyproject.toml",
-                             targetpath=pbc_pth))
-
-    # cross-compilation local override
-    root.insert(
-        OverrideConfigOption("py-build-cmake.cross.toml",
-                             "Allows you to override the cross-"
-                             "compilation settings in pyproject.toml",
-                             targetpath=cross_pth))
-
-    return root
-
-
-def get_component_options(project_path: Path, *, test: bool = False):
-    root = ConfigOption("root")
-    pyproject = root.insert(UncheckedConfigOption("pyproject.toml"))
-    project = pyproject.insert(UncheckedConfigOption('project'))
-    project.insert(UncheckedConfigOption('name', default=RequiredValue()))
-    tool = pyproject.insert(
-        UncheckedConfigOption("tool",
-                              default=DefaultValueValue({}),
-                              create_if_inheritance_target_exists=True))
-    pbc = tool.insert(
-        ConfigOption("py-build-cmake",
-                     default=DefaultValueValue({}),
-                     create_if_inheritance_target_exists=True))
-
-    # [tool.py-build-cmake.component]
-    component = pbc.insert(
-        ConfigOption(
-            "component",
-            "Options for a separately packaged component.",
-            default=DefaultValueValue({}),
-        ))
-    component.insert_multiple([
-        PathConfigOption('main_project',
-                         "Directory containing the main pyproject.toml file.",
-                         default=DefaultValueValue(".."),
-                         base_path=RelativeToProject(project_path),
-                         must_exist=not test),
-        ListOfStrConfigOption('build_presets',
-                              "CMake presets to use for building. Passed as "
-                              "`--preset <?>` during the build phase, once "
-                              "for each preset.",
-                              default=NoDefaultValue(),
-                              convert_str_to_singleton=True),
-        ListOfStrConfigOption('install_presets',
-                              "CMake presets to use for installing. Passed as "
-                              "`--preset <?>` during the installation phase, "
-                              "once for each preset.",
-                              default=RefDefaultValue(pth('build_presets'),
-                                                      relative=True),
-                              convert_str_to_singleton=True),
-        ListOfStrConfigOption('build_args',
-                              "Extra arguments passed to the build step.",
-                              "build_args = [\"-j\", \"--target\", \"foo\"]",
-                              default=NoDefaultValue()),
-        ListOfStrConfigOption('build_tool_args',
-                              "Extra arguments passed to the build tool in the "
-                              "build step (e.g. to Make or Ninja).",
-                              "build_tool_args = "
-                              "[\"--verbose\", \"-d\", \"explain\"]",
-                              default=NoDefaultValue()),
-        BoolConfigOption('install_only',
-                         "Do not build the project, only install it.",
-                         "install_only = true",
-                         default=DefaultValueValue(False)),
-        ListOfStrConfigOption('install_args',
-                              "Extra arguments passed to the install step.",
-                              "install_args = [\"--strip\"]",
-                              default=NoDefaultValue()),
-        ListOfStrConfigOption("install_components",
-                              "List of components to install, the install step "
-                              "is executed once for each component, with the "
-                              "option `--component <?>`.",
-                              default=RequiredValue()),
-    ]) # yapf: disable
-
-    return root
diff --git a/src/py_build_cmake/tags.py b/src/py_build_cmake/tags.py
deleted file mode 100644
index a647f82..0000000
--- a/src/py_build_cmake/tags.py
+++ /dev/null
@@ -1,83 +0,0 @@
-"""
-distlib.wheel doesn't always return the correct tags, and packaging.tags
-returns all tags supported by the interpreter, not the tags that should be used
-for the generated wheels. Therefore the only option here is to write our own
-(kind of hacky) functions based on packaging.tags.
-"""
-
-from typing import Dict
-import sys
-import sysconfig
-from importlib.machinery import EXTENSION_SUFFIXES
-from distlib.util import get_platform as get_platform_dashes  # type: ignore
-
-_INTERPRETER_SHORT_NAMES: Dict[str, str] = {
-    "python": "py",
-    "cpython": "cp",
-    "pypy": "pp",
-    "ironpython": "ip",
-    "jython": "jy",
-}
-
-
-def _normalize_string(s: str) -> str:
-    return s.replace(".", "_").replace("-", "_")
-
-
-def get_platform_tag() -> str:
-    return _normalize_string(get_platform_dashes())
-
-
-def get_interpreter_name() -> str:
-    name = sys.implementation.name
-    return _INTERPRETER_SHORT_NAMES.get(name) or name
-
-
-def get_interpreter_version() -> str:
-    return "".join(map(str, sys.version_info[:2]))
-
-
-def get_cpython_interpreter() -> str:
-    return f"cp{get_interpreter_version()}"
-
-
-def get_cpython_abi() -> str:
-    """
-    Get the ABI string for CPython, e.g. cp37m.
-
-    https://github.com/pypa/packaging/blob/917612f5774571a99902b5fe04d06099b9e8b667/packaging/tags.py#L135
-    """
-    py_version = sys.version_info[:2]
-    debug = pymalloc = ""
-    with_debug = sysconfig.get_config_var("Py_DEBUG")
-    has_refcount = hasattr(sys, "gettotalrefcount")
-    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
-    # extension modules is the best option.
-    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
-    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
-    if with_debug or (with_debug is None and (has_refcount or has_ext)):
-        debug = "d"
-    if py_version < (3, 8):
-        with_pymalloc = sysconfig.get_config_var("WITH_PYMALLOC")
-        if with_pymalloc or with_pymalloc is None:
-            pymalloc = "m"
-    return f"{get_cpython_interpreter()}{debug}{pymalloc}"
-
-
-def get_generic_interpreter() -> str:
-    return f"{get_interpreter_name()}{get_interpreter_version()}"
-
-
-def get_generic_abi() -> str:
-    abi = sysconfig.get_config_var("SOABI") or "none"
-    return _normalize_string(abi)
-
-
-def get_python_tag() -> str:
-    if get_interpreter_name() == "cp": return get_cpython_interpreter()
-    else: return get_generic_interpreter()
-
-
-def get_abi_tag() -> str:
-    if get_interpreter_name() == "cp": return get_cpython_abi()
-    else: return get_generic_abi()
diff --git a/test-packages/bare-c-module/CMakeLists.txt b/test-packages/bare-c-module/CMakeLists.txt
new file mode 100644
index 0000000..caf5bbb
--- /dev/null
+++ b/test-packages/bare-c-module/CMakeLists.txt
@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.17)
+project(bare-c-module)
+
+# Find the Python development files
+find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
+
+# Add the module to compile
+Python3_add_library(bare_c_module MODULE "add_module.c" WITH_SOABI)
+
+# Install the module
+install(TARGETS bare_c_module
+        EXCLUDE_FROM_ALL
+        COMPONENT python_modules
+        DESTINATION .)
diff --git a/test-packages/bare-c-module/LICENSE b/test-packages/bare-c-module/LICENSE
new file mode 100644
index 0000000..e69de29
diff --git a/test-packages/bare-c-module/README.md b/test-packages/bare-c-module/README.md
new file mode 100644
index 0000000..a74cde0
--- /dev/null
+++ b/test-packages/bare-c-module/README.md
@@ -0,0 +1,3 @@
+# Bare C module
+
+No subdirectories or `__init__.py` files.
diff --git a/test-packages/bare-c-module/add_module.c b/test-packages/bare-c-module/add_module.c
new file mode 100644
index 0000000..df90b12
--- /dev/null
+++ b/test-packages/bare-c-module/add_module.c
@@ -0,0 +1,51 @@
+/* Example based on https://docs.python.org/3/extending/extending.html */
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+/* This is the addition function we wish to expose to Python. */
+long add(long a, long b) {
+    return a + b;
+}
+
+/* Docstring for our Python module. */
+PyDoc_STRVAR(
+    docstring,
+    "Simple module that adds integers. "
+    "Based loosely on https://docs.python.org/3/extending/extending.html");
+
+/* Wrapper for our 'add' function, using the Python C API to get the function
+   arguments as integers, and to return the result as a Python object. */
+static PyObject *add_module_add(PyObject *self, PyObject *args) {
+    (void)self;
+    long a, b;
+    if (!PyArg_ParseTuple(args, "ll", &a, &b))
+        return NULL;
+    long result = add(a, b);
+    return PyLong_FromLong(result);
+}
+
+/* Define the functions/methods that this module exports. */
+static PyMethodDef AddModuleMethods[] = {
+    {"add", add_module_add, METH_VARARGS, "Add two integers."},
+    {NULL, NULL, 0, NULL}, /* Sentinel */
+};
+
+/* Define the actual module. */
+static struct PyModuleDef add_module = {
+    PyModuleDef_HEAD_INIT,
+    "bare_c_module", /* name of module */
+    docstring,       /* module documentation, may be NULL */
+    -1,              /* size of per-interpreter state of the module, or -1 if
+                        the module keeps state in global variables. */
+    AddModuleMethods,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+};
+
+/* The main entry point that is called by Python when our module is imported. */
+PyMODINIT_FUNC PyInit_bare_c_module(void) {
+    return PyModule_Create(&add_module);
+}
diff --git a/test-packages/bare-c-module/pyproject.toml b/test-packages/bare-c-module/pyproject.toml
new file mode 100644
index 0000000..a8bc46e
--- /dev/null
+++ b/test-packages/bare-c-module/pyproject.toml
@@ -0,0 +1,45 @@
+[project]
+name = "bare_c_module"
+version = "0.3.0"
+description = "Single extension module, without any folders or __init__.py"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { "file" = "LICENSE" }
+authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
+keywords = ["example", "addition", "subtraction"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+]
+urls = { "Documentation" = "https://tttapa.github.io/" }
+dependencies = []
+
+[build-system]
+requires = ["py-build-cmake~=0.3.0"]
+build-backend = "py_build_cmake.build"
+
+[tool.py-build-cmake.module]
+generated = "module"
+
+[tool.py-build-cmake.sdist]
+include = ["CMakeLists.txt", "add_module.c"]
+
+[tool.py-build-cmake.cmake]
+minimum_version = "3.17"
+build_type = "RelWithDebInfo"
+build_args = ["-j"]
+install_components = ["python_modules"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
diff --git a/test-packages/bare-c-module/tests/test_add_module.py b/test-packages/bare-c-module/tests/test_add_module.py
new file mode 100644
index 0000000..f616470
--- /dev/null
+++ b/test-packages/bare-c-module/tests/test_add_module.py
@@ -0,0 +1,5 @@
+from bare_c_module import add
+
+
+def test_add():
+    assert add(1, 2) == 3
diff --git a/test-packages/cmake-options/CMakeLists.txt b/test-packages/cmake-options/CMakeLists.txt
new file mode 100644
index 0000000..d30976d
--- /dev/null
+++ b/test-packages/cmake-options/CMakeLists.txt
@@ -0,0 +1,94 @@
+cmake_minimum_required(VERSION 3.17)
+project(cmake-options)
+
+if (NOT DEFINED CACHE{OPTION_A} OR NOT OPTION_A STREQUAL "foo-bar")
+    message(SEND_ERROR "Failed - OPTION_A=\"${OPTION_A}\"")
+else()
+    list(LENGTH OPTION_A OPTION_A_LEN)
+    if (NOT OPTION_A_LEN EQUAL 1)
+        message(SEND_ERROR "Failed - OPTION_A_LEN=${OPTION_A_LEN}")
+    endif()
+    get_property(OPTION_A_TYPE CACHE OPTION_A PROPERTY TYPE)
+    if (NOT OPTION_A_TYPE STREQUAL "UNINITIALIZED")
+        message(SEND_ERROR "Failed - OPTION_A_TYPE=${OPTION_A_TYPE}")
+    endif()
+endif()
+
+if (NOT DEFINED CACHE{OPTION_B} OR NOT OPTION_B STREQUAL "foo\;bar")
+    message(SEND_ERROR "Failed - OPTION_B=\"${OPTION_B}\"")
+else()
+    list(LENGTH OPTION_B OPTION_B_LEN)
+    if (NOT OPTION_B_LEN EQUAL 1)
+        message(SEND_ERROR "Failed - OPTION_B_LEN=${OPTION_B_LEN}")
+    endif()
+    get_property(OPTION_B_TYPE CACHE OPTION_B PROPERTY TYPE)
+    if (NOT OPTION_B_TYPE STREQUAL "UNINITIALIZED")
+        message(SEND_ERROR "Failed - OPTION_B_TYPE=${OPTION_B_TYPE}")
+    endif()
+endif()
+
+if (NOT DEFINED CACHE{OPTION_C} OR NOT OPTION_C STREQUAL "foo;bar")
+    message(SEND_ERROR "Failed - OPTION_C=\"${OPTION_C}\"")
+else()
+    list(LENGTH OPTION_C OPTION_C_LEN)
+    if (NOT OPTION_C_LEN EQUAL 2)
+        message(SEND_ERROR "Failed - OPTION_C_LEN=${OPTION_C_LEN}")
+    endif()
+    get_property(OPTION_C_TYPE CACHE OPTION_C PROPERTY TYPE)
+    if (NOT OPTION_C_TYPE STREQUAL "UNINITIALIZED")
+        message(SEND_ERROR "Failed - OPTION_C_TYPE=${OPTION_C_TYPE}")
+    endif()
+endif()
+
+if (NOT DEFINED CACHE{OPTION_D} OR NOT OPTION_D)
+    message(SEND_ERROR "Failed - OPTION_D=\"${OPTION_D}\"")
+else()
+    list(LENGTH OPTION_D OPTION_D_LEN)
+    if (NOT OPTION_D_LEN EQUAL 1)
+        message(SEND_ERROR "Failed - OPTION_D_LEN=${OPTION_D_LEN}")
+    endif()
+    get_property(OPTION_D_TYPE CACHE OPTION_D PROPERTY TYPE)
+    if (NOT OPTION_D_TYPE STREQUAL "BOOL")
+        message(SEND_ERROR "Failed - OPTION_D_TYPE=${OPTION_D_TYPE}")
+    endif()
+endif()
+
+if (NOT DEFINED CACHE{OPTION_E} OR NOT OPTION_E STREQUAL "/usr/bin/bash")
+    message(SEND_ERROR "Failed - OPTION_E=\"${OPTION_E}\"")
+else()
+    list(LENGTH OPTION_E OPTION_E_LEN)
+    if (NOT OPTION_E_LEN EQUAL 1)
+        message(SEND_ERROR "Failed - OPTION_E_LEN=${OPTION_E_LEN}")
+    endif()
+    get_property(OPTION_E_TYPE CACHE OPTION_E PROPERTY TYPE)
+    if (NOT OPTION_E_TYPE STREQUAL "FILEPATH")
+        message(SEND_ERROR "Failed - OPTION_E_TYPE=${OPTION_E_TYPE}")
+    endif()
+endif()
+
+if (LINUX)
+    set(OPTION_F_CMP "/some/linux/specific/path" "/usr/some/path")
+elseif(WIN32)
+    set(OPTION_F_CMP "/some/windows/specific/path" "/usr/some/path")
+elseif(APPLE)
+    set(OPTION_F_CMP "/some/macos/specific/path" "/usr/some/path")
+else()
+    set(OPTION_F_CMP "/usr/some/path")
+endif()
+if (NOT DEFINED CACHE{OPTION_F} OR NOT OPTION_F STREQUAL OPTION_F_CMP)
+    message(SEND_ERROR "Failed - OPTION_F=\"${OPTION_F}\"")
+else()
+    list(LENGTH OPTION_F OPTION_F_LEN)
+    list(LENGTH OPTION_F_CMP OPTION_F_CMP_LEN)
+    if (NOT OPTION_F_LEN EQUAL OPTION_F_CMP_LEN)
+        message(SEND_ERROR "Failed - OPTION_F_LEN=${OPTION_F_LEN}")
+    endif()
+    get_property(OPTION_F_TYPE CACHE OPTION_F PROPERTY TYPE)
+    if (NOT OPTION_F_TYPE STREQUAL "UNINITIALIZED")
+        message(SEND_ERROR "Failed - OPTION_F_TYPE=${OPTION_F_TYPE}")
+    endif()
+endif()
+
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/__init__.py" "# Empty")
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/__init__.py"
+    DESTINATION "${PY_BUILD_CMAKE_MODULE_NAME}")
diff --git a/test-packages/cmake-options/LICENSE b/test-packages/cmake-options/LICENSE
new file mode 100644
index 0000000..e69de29
diff --git a/test-packages/cmake-options/README.md b/test-packages/cmake-options/README.md
new file mode 100644
index 0000000..7268a13
--- /dev/null
+++ b/test-packages/cmake-options/README.md
@@ -0,0 +1,3 @@
+# CMake options
+
+Check parsing of CMake options in config file.
diff --git a/test-packages/cmake-options/pyproject.toml b/test-packages/cmake-options/pyproject.toml
new file mode 100644
index 0000000..7a52c17
--- /dev/null
+++ b/test-packages/cmake-options/pyproject.toml
@@ -0,0 +1,39 @@
+[project]
+name = "cmake_options"
+version = "0.3.0"
+description = "Checks parsing and escaping of CMake options"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { "file" = "LICENSE" }
+authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
+keywords = ["example"]
+classifiers = []
+urls = { "Documentation" = "https://tttapa.github.io/" }
+dependencies = []
+
+[build-system]
+requires = ["py-build-cmake~=0.3.0"]
+build-backend = "py_build_cmake.build"
+
+[tool.py-build-cmake.sdist]
+include = ["CMakeLists.txt"]
+
+[tool.py-build-cmake.module]
+generated = "package"
+
+[tool.py-build-cmake.cmake]
+minimum_version = "3.17"
+[tool.py-build-cmake.cmake.options]
+OPTION_A = "foo-bar"
+OPTION_B = "foo;bar"
+OPTION_C = ["foo", "bar"]
+OPTION_D = true
+OPTION_E = {"value" = "/usr/bin/bash", "type" = "FILEPATH"}
+OPTION_F = "/usr/some/path"
+
+[tool.py-build-cmake.linux.cmake.options]
+OPTION_F = {"prepend" = "/some/linux/specific/path"}
+[tool.py-build-cmake.windows.cmake.options]
+OPTION_F = {"prepend" = "/some/windows/specific/path"}
+[tool.py-build-cmake.mac.cmake.options]
+OPTION_F = {"prepend" = "/some/macos/specific/path"}
diff --git a/test-packages/cmake-options/tests/test_placeholder.py b/test-packages/cmake-options/tests/test_placeholder.py
new file mode 100644
index 0000000..bdbec05
--- /dev/null
+++ b/test-packages/cmake-options/tests/test_placeholder.py
@@ -0,0 +1,2 @@
+def test_placeholder():
+    import cmake_options  # noqa: F401
diff --git a/test-packages/cmake-preset/CMakeLists.txt b/test-packages/cmake-preset/CMakeLists.txt
new file mode 100644
index 0000000..887718d
--- /dev/null
+++ b/test-packages/cmake-preset/CMakeLists.txt
@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.17)
+project(cmake-preset)
+
+# Find the Python development files
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
+
+# Make sure that we got the secret from the CMakePresets.json file
+if (NOT PRESET_SECRET STREQUAL "secret-preset-value")
+    message(FATAL_ERROR "Invalid PRESET_SECRET")
+endif()
+
+# Add a custom target to generate a Python file
+add_custom_command(OUTPUT "__init__.py"
+    COMMAND ${Python3_EXECUTABLE}
+        ${CMAKE_CURRENT_SOURCE_DIR}/generate.py "${PRESET_SECRET}"
+    MAIN_DEPENDENCY generate.py)
+add_custom_target(init ALL DEPENDS "__init__.py")
+
+# Install the module
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/__init__.py"
+    DESTINATION ${PY_BUILD_CMAKE_MODULE_NAME}
+    COMPONENT python_modules
+    EXCLUDE_FROM_ALL)
diff --git a/test-packages/cmake-preset/CMakePresets.json b/test-packages/cmake-preset/CMakePresets.json
new file mode 100644
index 0000000..0e7690d
--- /dev/null
+++ b/test-packages/cmake-preset/CMakePresets.json
@@ -0,0 +1,21 @@
+{
+    "version": 3,
+    "cmakeMinimumRequired": {
+        "major": 3,
+        "minor": 21,
+        "patch": 0
+    },
+    "configurePresets": [
+        {
+            "name": "the-cmake-preset",
+            "displayName": "Custom CMake Config",
+            "binaryDir": "${sourceDir}/build/default",
+            "cacheVariables": {
+                "PRESET_SECRET": {
+                    "type": "STRING",
+                    "value": "secret-preset-value"
+                }
+            }
+        }
+    ]
+}
diff --git a/test-packages/cmake-preset/LICENSE b/test-packages/cmake-preset/LICENSE
new file mode 100644
index 0000000..e69de29
diff --git a/test-packages/cmake-preset/README.md b/test-packages/cmake-preset/README.md
new file mode 100644
index 0000000..0c79a25
--- /dev/null
+++ b/test-packages/cmake-preset/README.md
@@ -0,0 +1,3 @@
+# CMake Preset
+
+Use of `CMakePresets.json`.
diff --git a/test-packages/cmake-preset/generate.py b/test-packages/cmake-preset/generate.py
new file mode 100644
index 0000000..8ede83c
--- /dev/null
+++ b/test-packages/cmake-preset/generate.py
@@ -0,0 +1,5 @@
+import sys
+from pathlib import Path
+
+with Path("__init__.py").open("w") as f:
+    f.write('secret = "' + sys.argv[1] + '"')
diff --git a/test-packages/cmake-preset/pyproject.toml b/test-packages/cmake-preset/pyproject.toml
new file mode 100644
index 0000000..300bca2
--- /dev/null
+++ b/test-packages/cmake-preset/pyproject.toml
@@ -0,0 +1,26 @@
+[project]
+name = "cmake-preset"
+version = "0.3.0"
+description = "Test the use of CMake presets"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { "file" = "LICENSE" }
+authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
+
+[build-system]
+requires = ["py-build-cmake~=0.3.0"]
+build-backend = "py_build_cmake.build"
+
+[tool.py-build-cmake.module]
+generated = "package"
+
+[tool.py-build-cmake.sdist]
+include = ["CMakeLists.txt", "generate.py", "CMakePresets.json"]
+
+[tool.py-build-cmake.cmake]
+minimum_version = "3.21"
+preset = "the-cmake-preset"
+install_components = ["python_modules"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
diff --git a/test-packages/cmake-preset/tests/test_generated_module.py b/test-packages/cmake-preset/tests/test_generated_module.py
new file mode 100644
index 0000000..5e4a262
--- /dev/null
+++ b/test-packages/cmake-preset/tests/test_generated_module.py
@@ -0,0 +1,5 @@
+from cmake_preset import secret
+
+
+def test_secret():
+    assert secret == "secret-preset-value"
diff --git a/test-packages/local-options/.gitignore b/test-packages/local-options/.gitignore
new file mode 100644
index 0000000..7a8efc4
--- /dev/null
+++ b/test-packages/local-options/.gitignore
@@ -0,0 +1,2 @@
+!py-build-cmake.local.toml
+!py-build-cmake.local.pbc
diff --git a/test-packages/local-options/CMakeLists.txt b/test-packages/local-options/CMakeLists.txt
new file mode 100644
index 0000000..e74770c
--- /dev/null
+++ b/test-packages/local-options/CMakeLists.txt
@@ -0,0 +1,105 @@
+cmake_minimum_required(VERSION 3.17)
+project(local-options)
+
+if (NOT DEFINED CACHE{OPTION_A} OR NOT OPTION_A STREQUAL "foo-bar-local-toml")
+    message(SEND_ERROR "Failed - OPTION_A=\"${OPTION_A}\"")
+else()
+    list(LENGTH OPTION_A OPTION_A_LEN)
+    if (NOT OPTION_A_LEN EQUAL 1)
+        message(SEND_ERROR "Failed - OPTION_A_LEN=${OPTION_A_LEN}")
+    endif()
+    get_property(OPTION_A_TYPE CACHE OPTION_A PROPERTY TYPE)
+    if (NOT OPTION_A_TYPE STREQUAL "UNINITIALIZED")
+        message(SEND_ERROR "Failed - OPTION_A_TYPE=${OPTION_A_TYPE}")
+    endif()
+endif()
+
+if (NOT DEFINED CACHE{OPTION_B} OR NOT OPTION_B STREQUAL "baz\;local")
+    message(SEND_ERROR "Failed - OPTION_B=\"${OPTION_B}\"")
+else()
+    list(LENGTH OPTION_B OPTION_B_LEN)
+    if (NOT OPTION_B_LEN EQUAL 1)
+        message(SEND_ERROR "Failed - OPTION_B_LEN=${OPTION_B_LEN}")
+    endif()
+    get_property(OPTION_B_TYPE CACHE OPTION_B PROPERTY TYPE)
+    if (NOT OPTION_B_TYPE STREQUAL "UNINITIALIZED")
+        message(SEND_ERROR "Failed - OPTION_B_TYPE=${OPTION_B_TYPE}")
+    endif()
+endif()
+
+if (NOT DEFINED CACHE{OPTION_C} OR NOT OPTION_C STREQUAL "foo;bar;local-toml;local-pbc")
+    message(SEND_ERROR "Failed - OPTION_C=\"${OPTION_C}\"")
+else()
+    list(LENGTH OPTION_C OPTION_C_LEN)
+    if (NOT OPTION_C_LEN EQUAL 4)
+        message(SEND_ERROR "Failed - OPTION_C_LEN=${OPTION_C_LEN}")
+    endif()
+    get_property(OPTION_C_TYPE CACHE OPTION_C PROPERTY TYPE)
+    if (NOT OPTION_C_TYPE STREQUAL "UNINITIALIZED")
+        message(SEND_ERROR "Failed - OPTION_C_TYPE=${OPTION_C_TYPE}")
+    endif()
+endif()
+
+if (NOT DEFINED CACHE{OPTION_D} OR NOT OPTION_D)
+    message(SEND_ERROR "Failed - OPTION_D=\"${OPTION_D}\"")
+else()
+    list(LENGTH OPTION_D OPTION_D_LEN)
+    if (NOT OPTION_D_LEN EQUAL 1)
+        message(SEND_ERROR "Failed - OPTION_D_LEN=${OPTION_D_LEN}")
+    endif()
+    get_property(OPTION_D_TYPE CACHE OPTION_D PROPERTY TYPE)
+    if (NOT OPTION_D_TYPE STREQUAL "BOOL")
+        message(SEND_ERROR "Failed - OPTION_D_TYPE=${OPTION_D_TYPE}")
+    endif()
+endif()
+
+if (NOT DEFINED CACHE{OPTION_E} OR NOT OPTION_E STREQUAL "/usr/bin/local-toml")
+    message(SEND_ERROR "Failed - OPTION_E=\"${OPTION_E}\"")
+else()
+    list(LENGTH OPTION_E OPTION_E_LEN)
+    if (NOT OPTION_E_LEN EQUAL 1)
+        message(SEND_ERROR "Failed - OPTION_E_LEN=${OPTION_E_LEN}")
+    endif()
+    get_property(OPTION_E_TYPE CACHE OPTION_E PROPERTY TYPE)
+    if (NOT OPTION_E_TYPE STREQUAL "FILEPATH")
+        message(SEND_ERROR "Failed - OPTION_E_TYPE=${OPTION_E_TYPE}")
+    endif()
+endif()
+
+if (LINUX)
+    set(OPTION_F_CMP "/some/local/linux/path" "/some/linux/specific/path" "/usr/some/path")
+elseif(WIN32)
+    set(OPTION_F_CMP "/some/local/windows/path" "/some/windows/specific/path" "/usr/some/path")
+elseif(APPLE)
+    set(OPTION_F_CMP "/some/local/macos/path" "/some/macos/specific/path" "/usr/some/path")
+else()
+    set(OPTION_F_CMP "/some/local/path" "/usr/some/path")
+endif()
+if (NOT DEFINED CACHE{OPTION_F} OR NOT OPTION_F STREQUAL OPTION_F_CMP)
+    message(SEND_ERROR "Failed - OPTION_F=\"${OPTION_F}\"")
+else()
+    list(LENGTH OPTION_F OPTION_F_LEN)
+    list(LENGTH OPTION_F_CMP OPTION_F_CMP_LEN)
+    if (NOT OPTION_F_LEN EQUAL OPTION_F_CMP_LEN)
+        message(SEND_ERROR "Failed - OPTION_F_LEN=${OPTION_F_LEN}")
+    endif()
+    get_property(OPTION_F_TYPE CACHE OPTION_F PROPERTY TYPE)
+    if (NOT OPTION_F_TYPE STREQUAL "UNINITIALIZED")
+        message(SEND_ERROR "Failed - OPTION_F_TYPE=${OPTION_F_TYPE}")
+    endif()
+endif()
+
+if (DEFINED CACHE{Python3_EXECUTABLE})
+    message(SEND_ERROR "Failed - Python3_EXECUTABLE")
+endif()
+if (DEFINED CACHE{Python_EXECUTABLE})
+    message(SEND_ERROR "Failed - Python_EXECUTABLE")
+endif()
+
+if (NOT DEFINED ENV{MY_PATH} OR NOT "$ENV{MY_PATH}" STREQUAL "/opt/some-package")
+    message(SEND_ERROR "Failed - MY_PATH=\"$ENV{MY_PATH}\"")
+endif()
+
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/__init__.py" "# Empty")
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/__init__.py"
+    DESTINATION "${PY_BUILD_CMAKE_MODULE_NAME}")
diff --git a/test-packages/local-options/LICENSE b/test-packages/local-options/LICENSE
new file mode 100644
index 0000000..e69de29
diff --git a/test-packages/local-options/README.md b/test-packages/local-options/README.md
new file mode 100644
index 0000000..1b6e3b1
--- /dev/null
+++ b/test-packages/local-options/README.md
@@ -0,0 +1,3 @@
+# Local options
+
+Checks loading of local override files.
diff --git a/test-packages/local-options/py-build-cmake.local.pbc b/test-packages/local-options/py-build-cmake.local.pbc
new file mode 100644
index 0000000..c8c3c64
--- /dev/null
+++ b/test-packages/local-options/py-build-cmake.local.pbc
@@ -0,0 +1,9 @@
+cmake.options.OPTION_C+=local-pbc
+cmake.options.OPTION_D=True
+cmake.options.OPTION_E-=/usr/bin/bash
+linux.cmake.options.OPTION_F={prepend = /some/local/linux/path}
+windows.cmake.options.OPTION_F={prepend = /some/local/windows/path}
+mac.cmake.options.OPTION_F={prepend = /some/local/macos/path}
+cmake.env={MY_PATH = "/opt/some-package" }
+cmake.find_python=false
+cmake.find_python3=false
diff --git a/test-packages/local-options/py-build-cmake.local.toml b/test-packages/local-options/py-build-cmake.local.toml
new file mode 100644
index 0000000..aa91bba
--- /dev/null
+++ b/test-packages/local-options/py-build-cmake.local.toml
@@ -0,0 +1,7 @@
+[cmake.options]
+OPTION_A = "foo-bar-local-toml"
+OPTION_B = "baz;local"
+OPTION_C = {"append" = "local-toml"}
+OPTION_E = {"append" = "/usr/bin/local-toml"}
+[cmake.env]
+MY_PATH = "local"
diff --git a/test-packages/local-options/pyproject.toml b/test-packages/local-options/pyproject.toml
new file mode 100644
index 0000000..3de874a
--- /dev/null
+++ b/test-packages/local-options/pyproject.toml
@@ -0,0 +1,39 @@
+[project]
+name = "local_options"
+version = "0.3.0"
+description = "Checks loading of local override files"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { "file" = "LICENSE" }
+authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
+keywords = ["example"]
+classifiers = []
+urls = { "Documentation" = "https://tttapa.github.io/" }
+dependencies = []
+
+[build-system]
+requires = ["py-build-cmake~=0.3.0"]
+build-backend = "py_build_cmake.build"
+
+[tool.py-build-cmake.sdist]
+include = ["CMakeLists.txt"]
+
+[tool.py-build-cmake.module]
+generated = "package"
+
+[tool.py-build-cmake.cmake]
+minimum_version = "3.17"
+[tool.py-build-cmake.cmake.options]
+OPTION_A = "foo-bar"
+OPTION_B = "foo;bar"
+OPTION_C = ["foo", "bar"]
+OPTION_D = false
+OPTION_E = {"value" = "/usr/bin/bash", "type" = "FILEPATH"}
+OPTION_F = "/usr/some/path"
+
+[tool.py-build-cmake.linux.cmake.options]
+OPTION_F = {"prepend" = "/some/linux/specific/path"}
+[tool.py-build-cmake.windows.cmake.options]
+OPTION_F = {"prepend" = "/some/windows/specific/path"}
+[tool.py-build-cmake.mac.cmake.options]
+OPTION_F = {"prepend" = "/some/macos/specific/path"}
diff --git a/test-packages/local-options/tests/test_placeholder.py b/test-packages/local-options/tests/test_placeholder.py
new file mode 100644
index 0000000..ec05149
--- /dev/null
+++ b/test-packages/local-options/tests/test_placeholder.py
@@ -0,0 +1,2 @@
+def test_placeholder():
+    import local_options  # noqa: F401
diff --git a/test-packages/namespace-project-a/CMakeLists.txt b/test-packages/namespace-project-a/CMakeLists.txt
new file mode 100644
index 0000000..379fd04
--- /dev/null
+++ b/test-packages/namespace-project-a/CMakeLists.txt
@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.18)
+project(pybind11-project VERSION 0.3.0)
+set(PY_VERSION_SUFFIX "")
+set(PY_FULL_VERSION ${PROJECT_VERSION}${PY_VERSION_SUFFIX})
+
+# Make sure that the Python and CMake versions match
+if (DEFINED PY_BUILD_CMAKE_PACKAGE_VERSION)
+    if (NOT "${PY_BUILD_CMAKE_PACKAGE_VERSION}" MATCHES "^${PY_FULL_VERSION}$")
+        message(FATAL_ERROR "Version number does not match "
+                             "(${PY_BUILD_CMAKE_PACKAGE_VERSION} - ${PY_FULL_VERSION}).")
+    endif()
+endif()
+
+# Find the Python interpreter and the development files
+if (CMAKE_CROSSCOMPILING AND NOT (APPLE AND "$ENV{CIBUILDWHEEL}" STREQUAL "1"))
+    find_package(Python3 REQUIRED COMPONENTS Development.Module)
+else()
+    find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
+endif()
+
+# Make build reproducible and independent of Python installation directory.
+include(cmake/Reproducible.cmake)
+
+# Find the pybind11 package
+include(cmake/QueryPythonForPybind11.cmake)
+find_pybind11_python_first()
+
+# Compile the example Python module
+pybind11_add_module(_add_module MODULE "src/add_module.cpp")
+set_target_properties(_add_module PROPERTIES
+    DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}${PYTHON_MODULE_DEBUG_POSTFIX}")
+target_compile_definitions(_add_module PRIVATE
+    MODULE_NAME=$<TARGET_FILE_BASE_NAME:_add_module>
+    VERSION_INFO="${PY_FULL_VERSION}"
+)
+# Hide all symbols by default (including external libraries on Linux)
+set_target_properties(_add_module PROPERTIES
+    CXX_VISIBILITY_PRESET "hidden"
+    VISIBILITY_INLINES_HIDDEN true)
+if (CMAKE_SYSTEM_NAME MATCHES "Linux")
+    target_link_options(_add_module PRIVATE "LINKER:--exclude-libs,ALL")
+endif()
+
+# Install the Python module
+install(TARGETS _add_module
+        EXCLUDE_FROM_ALL
+        COMPONENT python_modules
+        DESTINATION ${PY_BUILD_CMAKE_MODULE_NAME})
+
+# Generate stubs for the Python module
+set(WITH_PY_STUBS_DEFAULT On)
+if (CMAKE_CROSSCOMPILING)
+    set(WITH_PY_STUBS_DEFAULT Off)
+endif()
+option(WITH_PY_STUBS
+    "Generate Python stub files (.pyi) for the Python module."
+    ${WITH_PY_STUBS_DEFAULT})
+if (WITH_PY_STUBS)
+    include(cmake/Pybind11Stubgen.cmake)
+    pybind11_stubgen(_add_module
+        PACKAGE ${PY_BUILD_CMAKE_MODULE_NAME}
+        COMPONENT python_stubs)
+endif()
diff --git a/test-packages/namespace-project-a/LICENSE b/test-packages/namespace-project-a/LICENSE
new file mode 100644
index 0000000..bfe4528
--- /dev/null
+++ b/test-packages/namespace-project-a/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Pieter P
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/test-packages/namespace-project-a/README.md b/test-packages/namespace-project-a/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/test-packages/namespace-project-a/cmake/Pybind11Stubgen.cmake b/test-packages/namespace-project-a/cmake/Pybind11Stubgen.cmake
new file mode 100644
index 0000000..96a7eb4
--- /dev/null
+++ b/test-packages/namespace-project-a/cmake/Pybind11Stubgen.cmake
@@ -0,0 +1,29 @@
+function(pybind11_stubgen target)
+
+    cmake_parse_arguments(STUBGEN "" "PACKAGE;DESTINATION;COMPONENT" "" ${ARGN})
+    if (NOT DEFINED STUBGEN_PACKAGE)
+        set(STUBGEN_PACKAGE ${PY_BUILD_CMAKE_MODULE_NAME})
+    endif()
+    if (NOT DEFINED STUBGEN_DESTINATION)
+        set(STUBGEN_DESTINATION "")
+    endif()
+    if (NOT DEFINED STUBGEN_COMPONENT)
+        set(STUBGEN_COMPONENT "python_stubs")
+    endif()
+
+    if (NOT DEFINED Python3_EXECUTABLE)
+        find_package(Python3 REQUIRED COMPONENTS Interpreter)
+    endif()
+
+    set(STUBGEN_MODULE ${STUBGEN_PACKAGE}.$<TARGET_FILE_BASE_NAME:${target}>)
+    set(STUBGEN_CMD "\"${Python3_EXECUTABLE}\" -m pybind11_stubgen -o . --exit-code \"${STUBGEN_MODULE}\"")
+    install(CODE "
+        execute_process(COMMAND ${STUBGEN_CMD}
+                        WORKING_DIRECTORY \"\${CMAKE_INSTALL_PREFIX}/${STUBGEN_DESTINATION}\"
+                        RESULT_VARIABLE STUBGEN_RET)
+        if(NOT STUBGEN_RET EQUAL 0)
+            message(SEND_ERROR \"pybind11-stubgen ${STUBGEN_MODULE} failed.\")
+        endif()
+        " EXCLUDE_FROM_ALL COMPONENT ${STUBGEN_COMPONENT})
+
+endfunction()
diff --git a/test-packages/namespace-project-a/cmake/QueryPythonForPybind11.cmake b/test-packages/namespace-project-a/cmake/QueryPythonForPybind11.cmake
new file mode 100644
index 0000000..93b278b
--- /dev/null
+++ b/test-packages/namespace-project-a/cmake/QueryPythonForPybind11.cmake
@@ -0,0 +1,43 @@
+option(USE_GLOBAL_PYBIND11 "Don't query Python to find pybind11" Off)
+mark_as_advanced(USE_GLOBAL_PYBIND11)
+
+# First tries to find Python 3, then tries to import the pybind11 module to
+# query the CMake config location, and finally imports pybind11 using
+# find_package(pybind11 ${ARGN} REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH),
+# where ${ARGN} are the arguments passed to this macro.
+macro(find_pybind11_python_first)
+
+    # https://github.com/pybind/pybind11/pull/5083
+    set(PYBIND11_USE_CROSSCOMPILING On)
+
+    # Find Python
+    if (CMAKE_CROSSCOMPILING AND NOT (APPLE AND "$ENV{CIBUILDWHEEL}" STREQUAL "1"))
+        find_package(Python3 REQUIRED COMPONENTS Development.Module)
+    else()
+        find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
+    endif()
+
+    # Query Python to see if it knows where the pybind11 root is
+    if (NOT USE_GLOBAL_PYBIND11 AND Python3_EXECUTABLE)
+        if (NOT pybind11_ROOT OR NOT EXISTS ${pybind11_ROOT})
+            message(STATUS "Detecting pybind11 CMake location")
+            execute_process(COMMAND ${Python3_EXECUTABLE}
+                    -m pybind11 --cmakedir
+                OUTPUT_VARIABLE PY_BUILD_PYBIND11_ROOT
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                RESULT_VARIABLE PY_BUILD_CMAKE_PYBIND11_RESULT)
+            # If it was successful
+            if (PY_BUILD_CMAKE_PYBIND11_RESULT EQUAL 0)
+                message(STATUS "pybind11 CMake location: ${PY_BUILD_PYBIND11_ROOT}")
+                set(pybind11_ROOT ${PY_BUILD_PYBIND11_ROOT}
+                    CACHE PATH "Path to the pybind11 CMake configuration." FORCE)
+            else()
+                unset(pybind11_ROOT CACHE)
+            endif()
+        endif()
+    endif()
+
+    # pybind11 is header-only, so finding a native version is fine
+    find_package(pybind11 ${ARGN} REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH)
+
+endmacro()
diff --git a/test-packages/namespace-project-a/cmake/Reproducible.cmake b/test-packages/namespace-project-a/cmake/Reproducible.cmake
new file mode 100644
index 0000000..ea44df2
--- /dev/null
+++ b/test-packages/namespace-project-a/cmake/Reproducible.cmake
@@ -0,0 +1,23 @@
+# We want to avoid the temporary build paths used by PyPA build and pip to
+# be included in the binaries, because that would make the whole package non-
+# reproducible. Therefore, we strip out the paths of the build environment and
+# of the project folder.
+# https://reproducible-builds.org/docs/build-path/
+
+set(PYTHON_DIRS ${Python3_STDLIB} ${Python3_STDARCH} ${Python3_SITELIB} ${Python3_SITEARCH})
+list(REMOVE_DUPLICATES PYTHON_DIRS)
+list(FILTER PYTHON_DIRS INCLUDE REGEX "/(pip-)?build-env-")
+foreach(d PYTHON_DIRS)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "(^GNU$)|(Clang$)")
+        add_compile_options("-ffile-prefix-map=${d}=/build-env")
+    endif()
+endforeach()
+
+option(REPRODUCIBLE_PROJECT_DIR Off
+    "Add a file prefix map for the project source directory itself")
+
+if (REPRODUCIBLE_PROJECT_DIR)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "(^GNU$)|(Clang$)")
+        add_compile_options("-ffile-prefix-map=${PROJECT_SOURCE_DIR}=/${PROJECT_NAME}")
+    endif()
+endif()
diff --git a/test-packages/namespace-project-a/pyproject.toml b/test-packages/namespace-project-a/pyproject.toml
new file mode 100644
index 0000000..756c078
--- /dev/null
+++ b/test-packages/namespace-project-a/pyproject.toml
@@ -0,0 +1,45 @@
+[project]
+name = "namespace-project-a" # Name on PyPI
+version = "0.3.0"
+readme = "README.md"
+description = "Part A of a namespace package"
+requires-python = ">=3.7"
+license = { "file" = "LICENSE" }
+authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
+keywords = ["example", "addition", "pybind11"]
+classifiers = []
+urls = { "Documentation" = "https://tttapa.github.io/" }
+dependencies = []
+
+[build-system]
+requires = [
+    "py-build-cmake~=0.3.0",
+    "pybind11~=2.13.6",
+    "pybind11-stubgen~=2.5.1",
+]
+build-backend = "py_build_cmake.build"
+
+[tool.py-build-cmake.module]
+name = "namespace_project" # Import name
+directory = "python-src"
+namespace = true
+
+[tool.py-build-cmake.editable]
+mode = "hook"
+
+[tool.py-build-cmake.sdist]
+include = ["CMakeLists.txt", "cmake/*.cmake", "src/*.cpp", "src/*.hpp"]
+exclude = []
+
+[tool.py-build-cmake.cmake]
+minimum_version = "3.18"
+build_type = "Release"
+source_path = "." # Containing CMakeLists.txt
+build_args = ["-j"]
+install_components = ["python_modules", "python_stubs"]
+
+[tool.py-build-cmake.stubgen]
+packages = ["namespace_project.add_module"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
diff --git a/test-packages/namespace-project-a/python-src/namespace_project/add_module.py b/test-packages/namespace-project-a/python-src/namespace_project/add_module.py
new file mode 100644
index 0000000..e3eaa1b
--- /dev/null
+++ b/test-packages/namespace-project-a/python-src/namespace_project/add_module.py
@@ -0,0 +1,4 @@
+"""Example module that adds two integers in C++."""
+
+from ._add_module import *  # noqa: F403
+from ._add_module import __version__  # noqa: F401, RUF100
diff --git a/test-packages/namespace-project-a/python-src/namespace_project/py.typed b/test-packages/namespace-project-a/python-src/namespace_project/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/test-packages/namespace-project-a/src/add_module.cpp b/test-packages/namespace-project-a/src/add_module.cpp
new file mode 100644
index 0000000..893633f
--- /dev/null
+++ b/test-packages/namespace-project-a/src/add_module.cpp
@@ -0,0 +1,22 @@
+/**
+ * @file    Example C++ extension for Python using Pybind11 that adds two
+ *          integers.
+ */
+
+#include <cstdint>
+#include <pybind11/pybind11.h>
+using pybind11::operator""_a;
+
+int32_t add(int32_t a, int32_t b) {
+    return a + b;
+}
+
+PYBIND11_MODULE(MODULE_NAME, m) {
+    m.doc()               = "Module for adding integers";
+    m.attr("__version__") = VERSION_INFO;
+    m.def("add",              // function name in Python
+          add,                // C++ function
+          "a"_a, "b"_a,       // Argument names in Python
+          "Adds two integers" // Docstring in Python
+    );
+}
diff --git a/test-packages/namespace-project-a/tests/test_add_module.py b/test-packages/namespace-project-a/tests/test_add_module.py
new file mode 100644
index 0000000..fef783f
--- /dev/null
+++ b/test-packages/namespace-project-a/tests/test_add_module.py
@@ -0,0 +1,18 @@
+import sys
+
+import pytest
+from namespace_project.add_module import __version__, add
+
+
+def test_add():
+    assert add(1, 2) == 3
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 8),
+    reason="No importlib.metadata.version support on older versions of Python",
+)
+def test_version():
+    from importlib.metadata import version
+
+    assert __version__ == version("namespace_project_a")
diff --git a/test-packages/namespace-project-b/LICENSE b/test-packages/namespace-project-b/LICENSE
new file mode 100644
index 0000000..bfe4528
--- /dev/null
+++ b/test-packages/namespace-project-b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Pieter P
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/test-packages/namespace-project-b/README.md b/test-packages/namespace-project-b/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/test-packages/namespace-project-b/pyproject.toml b/test-packages/namespace-project-b/pyproject.toml
new file mode 100644
index 0000000..cea245a
--- /dev/null
+++ b/test-packages/namespace-project-b/pyproject.toml
@@ -0,0 +1,32 @@
+[project]
+name = "namespace-project-b" # Name on PyPI
+version = "0.3.0"
+readme = "README.md"
+description = "Part B of a namespace package"
+requires-python = ">=3.7"
+license = { "file" = "LICENSE" }
+authors = [{ "name" = "Pieter P", "email" = "pieter.p.dev@outlook.com" }]
+keywords = ["example", "subtraction"]
+classifiers = []
+urls = { "Documentation" = "https://tttapa.github.io/" }
+dependencies = []
+
+[build-system]
+requires = [
+    "py-build-cmake~=0.3.0",
+]
+build-backend = "py_build_cmake.build"
+
+[tool.py-build-cmake.module]
+name = "namespace_project" # Import name
+directory = "python-src"
+namespace = true
+
+[tool.py-build-cmake.editable]
+mode = "hook"
+
+[tool.py-build-cmake.stubgen]
+packages = ["namespace_project.sub_module"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
diff --git a/test-packages/namespace-project-b/python-src/namespace_project/py.typed b/test-packages/namespace-project-b/python-src/namespace_project/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/examples/nanobind-project/python-src/nanobind_project/sub_package/sub.py b/test-packages/namespace-project-b/python-src/namespace_project/sub_module.py
similarity index 88%
rename from examples/nanobind-project/python-src/nanobind_project/sub_package/sub.py
rename to test-packages/namespace-project-b/python-src/namespace_project/sub_module.py
index 9fe9eb9..bc7e6aa 100644
--- a/examples/nanobind-project/python-src/nanobind_project/sub_package/sub.py
+++ b/test-packages/namespace-project-b/python-src/namespace_project/sub_module.py
@@ -3,4 +3,4 @@
 
 def sub(a: int, b: int) -> int:
     """Subtracts two integers"""
-    return a - b
\ No newline at end of file
+    return a - b
diff --git a/test-packages/namespace-project-b/tests/test_sub_module.py b/test-packages/namespace-project-b/tests/test_sub_module.py
new file mode 100644
index 0000000..447261e
--- /dev/null
+++ b/test-packages/namespace-project-b/tests/test_sub_module.py
@@ -0,0 +1,5 @@
+from namespace_project.sub_module import sub
+
+
+def test_sub():
+    assert sub(3, 2) == 1
diff --git a/test/test_configoptions.py b/test/test_configoptions.py
deleted file mode 100644
index 42ccb5a..0000000
--- a/test/test_configoptions.py
+++ /dev/null
@@ -1,1291 +0,0 @@
-import os
-from pathlib import Path
-from pprint import pprint
-
-import pytest
-import py_build_cmake.config_options as co
-from py_build_cmake.pyproject_options import get_options
-from flit_core.config import ConfigError
-
-
-def gen_test_opts():
-    leaf11 = co.StrConfigOption("leaf11")
-    leaf12 = co.StrConfigOption("leaf12")
-    mid1 = co.ConfigOption("mid1")
-    mid1.insert(leaf11)
-    mid1.insert(leaf12)
-    leaf21 = co.StrConfigOption("leaf21")
-    leaf22 = co.StrConfigOption("leaf22")
-    mid2 = co.ConfigOption("mid2")
-    mid2.insert(leaf21)
-    mid2.insert(leaf22)
-    trunk = co.ConfigOption("trunk")
-    trunk.insert(mid1)
-    trunk.insert(mid2)
-    opts = co.ConfigOption("root")
-    opts.insert(trunk)
-    return opts
-
-
-def test_iter():
-    opts = gen_test_opts()
-    result = [p for p in opts.iter_opt_paths()]
-    expected = [
-        ('trunk', ),
-        ('trunk', 'mid1'),
-        ('trunk', 'mid1', 'leaf11'),
-        ('trunk', 'mid1', 'leaf12'),
-        ('trunk', 'mid2'),
-        ('trunk', 'mid2', 'leaf21'),
-        ('trunk', 'mid2', 'leaf22'),
-    ]
-    print(result)
-    assert result == expected
-
-
-def test_iter_leaf():
-    opts = gen_test_opts()
-    result = [p for p in opts.iter_leaf_opt_paths()]
-    expected = [
-        ('trunk', 'mid1', 'leaf11'),
-        ('trunk', 'mid1', 'leaf12'),
-        ('trunk', 'mid2', 'leaf21'),
-        ('trunk', 'mid2', 'leaf22'),
-    ]
-    print(result)
-    assert result == expected
-
-
-def test_update_defaults():
-    opts = gen_test_opts()
-    trunk = opts[co.pth('trunk')]
-    assert trunk.name == "trunk"
-    mid1 = opts[co.pth('trunk/mid1')]
-    assert mid1.name == "mid1"
-    leaf12 = opts[co.pth('trunk/mid1/leaf12')]
-    assert leaf12.name == "leaf12"
-
-    cfg = co.ConfigNode.from_dict({})
-    trunk.default = co.DefaultValueValue({})
-    res = trunk.update_default(opts, cfg, co.pth('trunk'))
-    assert res is not None and res.value == {}
-    assert cfg.to_dict() == {"trunk": {}}
-    opts.update_default_all(cfg)
-    assert cfg.to_dict() == {"trunk": {}}
-
-    cfg = co.ConfigNode.from_dict({})
-    leaf12.default = co.DefaultValueValue("d12")
-    res = leaf12.update_default(opts, cfg, co.pth('trunk/mid1/leaf12'))
-    assert res is not None and res.value == "d12"
-    assert cfg.to_dict() == {}
-    opts.update_default_all(cfg)
-    assert cfg.to_dict() == {"trunk": {}}
-
-    cfg = co.ConfigNode.from_dict({})
-    mid1.default = co.DefaultValueValue({})
-    res = leaf12.update_default(opts, cfg, co.pth('trunk/mid1/leaf12'))
-    assert res is not None and res.value == "d12"
-    assert cfg.to_dict() == {}
-    opts.update_default_all(cfg)
-    assert cfg.to_dict() == {"trunk": {"mid1": {"leaf12": "d12"}}}
-
-    cfg = co.ConfigNode.from_dict({})
-    print(cfg)
-    print(cfg.value)
-    print(cfg.sub)
-    trunk.default = co.NoDefaultValue()
-    res = leaf12.update_default(opts, cfg, co.pth('trunk/mid1/leaf12'))
-    assert res is not None and res.value == "d12"
-    assert cfg.to_dict() == {}
-    print(cfg)
-    print(cfg.value)
-    print(cfg.sub)
-    opts.update_default_all(cfg)
-    assert cfg.to_dict() == {}
-
-
-def test_override0():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-        # No override
-    }
-    opts[co.pth('')].insert(
-        co.OverrideConfigOption(
-            'override_mid2',
-            '',
-            targetpath=co.pth('trunk/mid2'),
-        ))
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    opts.override_all(cfg)
-    assert cfg.to_dict() == {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-    }
-
-
-def test_override1():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-        "override_mid2": {
-            "leaf21": "23"
-        }
-    }
-    opts[co.pth('')].insert(
-        co.OverrideConfigOption(
-            'override_mid2',
-            '',
-            targetpath=co.pth('trunk/mid2'),
-        ))
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    opts.override_all(cfg)
-    assert cfg.to_dict() == {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "23",
-                "leaf22": "22",
-            },
-        },
-        "override_mid2": {
-            "leaf21": "23"
-        }
-    }
-
-
-def test_override2():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-        "override_mid2": {
-            "leaf21": "31",
-            "leaf22": "32",
-        },
-    }
-    opts[co.pth('')].insert(
-        co.OverrideConfigOption(
-            'override_mid2',
-            '',
-            targetpath=co.pth('trunk/mid2'),
-        ))
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    opts.override_all(cfg)
-    assert cfg.to_dict() == {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "31",
-                "leaf22": "32",
-            },
-        },
-        "override_mid2": {
-            "leaf21": "31",
-            "leaf22": "32",
-        },
-    }
-
-
-def test_override_trunk():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-        "override_trunk": {
-            "mid1": {
-                "leaf12": "33",
-            },
-            "mid2": {
-                "leaf21": "31",
-                "leaf22": "32",
-            },
-        },
-    }
-    opts[co.pth('')].insert(
-        co.OverrideConfigOption(
-            'override_trunk',
-            '',
-            targetpath=co.pth('trunk'),
-        ))
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    opts.override_all(cfg)
-    assert cfg.to_dict() == {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "33",
-            },
-            "mid2": {
-                "leaf21": "31",
-                "leaf22": "32",
-            },
-        },
-        "override_trunk": {
-            "mid1": {
-                "leaf12": "33",
-            },
-            "mid2": {
-                "leaf21": "31",
-                "leaf22": "32",
-            },
-        },
-    }
-
-
-def test_verify_override_unknown_keys():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-        "override_mid2": {
-            "blahblah": "31",
-            "leaf22": "32",
-        },
-    }
-    opts[co.pth('')].insert(
-        co.OverrideConfigOption(
-            'override_mid2',
-            '',
-            targetpath=co.pth('trunk/mid2'),
-        ))
-    cfg = co.ConfigNode.from_dict(d)
-    expected = 'Unkown options in override_mid2: blahblah'
-    with pytest.raises(ConfigError, match=expected) as e:
-        opts.verify_all(cfg)
-    print(e)
-
-
-def test_override_trunk_unknown_keys():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-        "override_trunk": {
-            "mid1": {
-                "azertyop": "33",
-            },
-        },
-    }
-    opts[co.pth('')].insert(
-        co.OverrideConfigOption(
-            'override_trunk',
-            '',
-            targetpath=co.pth('trunk'),
-        ))
-    cfg = co.ConfigNode.from_dict(d)
-    expected = 'Unkown options in override_trunk/mid1: azertyop'
-    with pytest.raises(ConfigError, match=expected) as e:
-        opts.verify_all(cfg)
-    print(e)
-
-
-def test_verify_unknown_keys1():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-            "mid3": "foobar",
-        },
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    expected = 'Unkown options in trunk: mid3'
-    with pytest.raises(ConfigError, match=expected) as e:
-        opts.verify_all(cfg)
-    print(e)
-
-
-def test_verify_unknown_keys2():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-                "foobar": 1234,
-            },
-        },
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    expected = 'Unkown options in trunk/mid2: foobar'
-    with pytest.raises(ConfigError, match=expected) as e:
-        opts.verify_all(cfg)
-    print(e)
-
-
-def test_verify_wrong_type_str():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": 1234,
-            },
-        },
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    expected = "Type of trunk/mid2/leaf22 should be <class 'str'>, " \
-               "not <class 'int'>"
-    with pytest.raises(ConfigError, match=expected) as e:
-        opts.verify_all(cfg)
-    print(e)
-
-
-def test_verify_wrong_type_str_dict():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": {
-                    "21": 1234
-                },
-            },
-        },
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    expected = "Type of trunk/mid2/leaf21 should be <class 'str'>, " \
-               "not <class 'dict'>"
-    with pytest.raises(ConfigError, match=expected) as e:
-        opts.verify_all(cfg)
-    print(e)
-
-
-def test_inherit():
-    opts = gen_test_opts()
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-            "mid3": {},
-        },
-    }
-    mid3 = opts[co.pth('trunk')].insert(
-        co.ConfigOption('mid3', inherit_from=co.pth('trunk/mid2')))
-
-    cfg = co.ConfigNode.from_dict(d)
-    mid3.inherit(opts, cfg, co.pth('trunk/mid3'))
-    assert cfg.to_dict() == {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-            "mid3": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-    }
-
-    cfg = co.ConfigNode.from_dict(d)
-    cfg.setdefault(co.pth('trunk/mid3/leaf22'), co.ConfigNode(value="32"))
-    mid3.inherit(opts, cfg, co.pth('trunk/mid3'))
-    assert cfg.to_dict() == {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-            "mid3": {
-                "leaf21": "21",
-                "leaf22": "32",
-            },
-        },
-    }
-
-
-def test_config_node():
-    d = {
-        "trunk": {
-            "mid1": {
-                "leaf11": "11",
-                "leaf12": "12",
-            },
-            "mid2": {
-                "leaf21": "21",
-                "leaf22": "22",
-            },
-        },
-    }
-    nodes = co.ConfigNode.from_dict(d)
-    for pth, val in nodes.iter_dfs():
-        print(pth, val)
-    assert nodes[co.pth('')] is nodes
-    assert nodes[co.pth('')].value is None
-    assert nodes[co.pth('trunk')].value is None
-    assert nodes[co.pth('trunk/mid1')].value is None
-    assert nodes[co.pth('trunk/mid2')].value is None
-    assert nodes[co.pth('trunk/mid1/leaf11')].value == "11"
-    assert nodes[co.pth('trunk/mid1/leaf12')].value == "12"
-    assert nodes[co.pth('trunk/mid2/leaf21')].value == "21"
-    assert nodes[co.pth('trunk/mid2/leaf22')].value == "22"
-
-    d2 = nodes.to_dict()
-    assert d2 == d
-
-
-def test_joinpth():
-    assert co.joinpth(co.pth('a/b/c'), co.pth('d/e')) == co.pth('a/b/c/d/e')
-    assert co.joinpth(co.pth('a/b/c'), co.pth('^/e')) == co.pth('a/b/e')
-    assert co.joinpth(co.pth('a/b/c'), co.pth('^/^/e')) == co.pth('a/e')
-    assert co.joinpth(co.pth('a/b/c'), co.pth('^/^/^/e')) == co.pth('e')
-    assert co.joinpth(co.pth('a/b/c'), co.pth('^/^/^/^/e')) == co.pth('^/e')
-
-
-def test_real_config_inherit_cross_cmake():
-    opts = get_options(Path('/project'), test=True)
-    d = {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    "cmake": {
-                        "build_type": "Release",
-                        "generator": "Ninja",
-                        "source_path": "src",
-                        "env": {
-                            "foo": "bar"
-                        },
-                        "args": ["arg1", "arg2"],
-                        "find_python": False,
-                        "find_python3": True,
-                    },
-                    "cross": {
-                        "implementation": "cp",
-                        "version": "310",
-                        "abi": "cp310",
-                        "arch": "linux_aarch64",
-                        "toolchain_file": "aarch64-linux-gnu.cmake",
-                        "cmake": {
-                            "generator": "Unix Makefiles",
-                            "build_type": "RelWithDebInfo",
-                            "env": {
-                                "crosscompiling": "true"
-                            },
-                            "args": ["arg3", "arg4"],
-                        },
-                    },
-                    "linux": {
-                        "cmake": {
-                            "install_components": ["linux_install"],
-                        }
-                    },
-                    "windows": {
-                        "cmake": {
-                            "install_components": ["win_install"],
-                        }
-                    }
-                }
-            }
-        }
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    pprint(cfg.to_dict())
-    opts.inherit_all(cfg)
-    pprint(cfg.to_dict())
-    assert cfg.to_dict() == {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    "cmake": {
-                        "build_type": "Release",
-                        "generator": "Ninja",
-                        "source_path": os.path.normpath("/project/src"),
-                        "args": ["arg1", "arg2"],
-                        "env": {
-                            "foo": "bar"
-                        },
-                        "find_python": False,
-                        "find_python3": True,
-                    },
-                    "cross": {
-                        "implementation":
-                        "cp",
-                        "version":
-                        "310",
-                        "abi":
-                        "cp310",
-                        "arch":
-                        "linux_aarch64",
-                        "toolchain_file":
-                        os.path.normpath("/project/aarch64-linux-gnu.cmake"),
-                        "cmake": {
-                            "build_type": "RelWithDebInfo",
-                            "generator": "Unix Makefiles",
-                            "source_path": os.path.normpath("/project/src"),
-                            "args": ["arg1", "arg2", "arg3", "arg4"],
-                            "find_python": False,
-                            "find_python3": True,
-                            "env": {
-                                "foo": "bar",
-                                "crosscompiling": "true",
-                            },
-                        },
-                    },
-                    "linux": {
-                        "cmake": {
-                            "build_type": "Release",
-                            "generator": "Ninja",
-                            "source_path": os.path.normpath("/project/src"),
-                            "args": ["arg1", "arg2"],
-                            "env": {
-                                "foo": "bar"
-                            },
-                            "install_components": ["linux_install"],
-                            "find_python": False,
-                            "find_python3": True,
-                        }
-                    },
-                    "windows": {
-                        "cmake": {
-                            "build_type": "Release",
-                            "generator": "Ninja",
-                            "source_path": os.path.normpath("/project/src"),
-                            "args": ["arg1", "arg2"],
-                            "env": {
-                                "foo": "bar"
-                            },
-                            "install_components": ["win_install"],
-                            "find_python": False,
-                            "find_python3": True,
-                        }
-                    },
-                    "mac": {
-                        "cmake": {
-                            "build_type": "Release",
-                            "generator": "Ninja",
-                            "source_path": os.path.normpath("/project/src"),
-                            "args": ["arg1", "arg2"],
-                            "env": {
-                                "foo": "bar"
-                            },
-                            "find_python": False,
-                            "find_python3": True,
-                        }
-                    },
-                }
-            }
-        }
-    }
-
-    opts.update_default_all(cfg)
-    pprint(cfg.to_dict())
-    assert cfg.to_dict() == {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    "module": {
-                        "name": "foobar",
-                        "directory": os.path.normpath("/project"),
-                    },
-                    "editable": {
-                        "mode": "wrapper",
-                    },
-                    "sdist": {
-                        "include": [],
-                        "exclude": [],
-                    },
-                    "cmake": {
-                        "build_type":
-                        "Release",
-                        "config": ["Release"],
-                        "generator":
-                        "Ninja",
-                        "source_path":
-                        os.path.normpath("/project/src"),
-                        "build_path":
-                        os.path.normpath("/project/.py-build-cmake_cache"),
-                        "options": {},
-                        "args": ["arg1", "arg2"],
-                        "find_python": False,
-                        "find_python3": True,
-                        "build_args": [],
-                        "build_tool_args": [],
-                        "install_args": [],
-                        "install_components": [""],
-                        "env": {
-                            "foo": "bar"
-                        },
-                    },
-                    "cross": {
-                        "implementation":
-                        "cp",
-                        "version":
-                        "310",
-                        "abi":
-                        "cp310",
-                        "arch":
-                        "linux_aarch64",
-                        "toolchain_file":
-                        os.path.normpath("/project/aarch64-linux-gnu.cmake"),
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                        "cmake": {
-                            "build_type":
-                            "RelWithDebInfo",
-                            "config": ["RelWithDebInfo"],
-                            "generator":
-                            "Unix Makefiles",
-                            "source_path":
-                            os.path.normpath("/project/src"),
-                            "build_path":
-                            os.path.normpath("/project/.py-build-cmake_cache"),
-                            "options": {},
-                            "args": ["arg1", "arg2", "arg3", "arg4"],
-                            "find_python": False,
-                            "find_python3": True,
-                            "build_args": [],
-                            "build_tool_args": [],
-                            "install_args": [],
-                            "install_components": [""],
-                            "env": {
-                                "foo": "bar",
-                                "crosscompiling": "true",
-                            },
-                        },
-                    },
-                    "linux": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                        "cmake": {
-                            "build_type":
-                            "Release",
-                            "config": ["Release"],
-                            "generator":
-                            "Ninja",
-                            "source_path":
-                            os.path.normpath("/project/src"),
-                            "build_path":
-                            os.path.normpath("/project/.py-build-cmake_cache"),
-                            "options": {},
-                            "args": ["arg1", "arg2"],
-                            "find_python": False,
-                            "find_python3": True,
-                            "build_args": [],
-                            "build_tool_args": [],
-                            "install_args": [],
-                            "install_components": ["linux_install"],
-                            "env": {
-                                "foo": "bar"
-                            },
-                        },
-                    },
-                    "windows": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                        "cmake": {
-                            "build_type":
-                            "Release",
-                            "config": ["Release"],
-                            "generator":
-                            "Ninja",
-                            "source_path":
-                            os.path.normpath("/project/src"),
-                            "build_path":
-                            os.path.normpath("/project/.py-build-cmake_cache"),
-                            "options": {},
-                            "args": ["arg1", "arg2"],
-                            "find_python": False,
-                            "find_python3": True,
-                            "build_args": [],
-                            "build_tool_args": [],
-                            "install_args": [],
-                            "install_components": ["win_install"],
-                            "env": {
-                                "foo": "bar"
-                            },
-                        }
-                    },
-                    "mac": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                        "cmake": {
-                            "build_type":
-                            "Release",
-                            "config": ["Release"],
-                            "generator":
-                            "Ninja",
-                            "source_path":
-                            os.path.normpath("/project/src"),
-                            "build_path":
-                            os.path.normpath("/project/.py-build-cmake_cache"),
-                            "options": {},
-                            "args": ["arg1", "arg2"],
-                            "find_python": False,
-                            "find_python3": True,
-                            "build_args": [],
-                            "build_tool_args": [],
-                            "install_args": [],
-                            "install_components": [""],
-                            "env": {
-                                "foo": "bar"
-                            },
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-
-def test_real_config_no_cross():
-    opts = get_options(Path('/project'), test=True)
-    d = {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    "cmake": {
-                        "build_type": "Release",
-                        "generator": "Ninja",
-                        "source_path": "src",
-                        "env": {
-                            "foo": "bar"
-                        },
-                        "args": ["arg1", "arg2"],
-                        "find_python": False,
-                        "find_python3": True,
-                    },
-                    "linux": {
-                        "cmake": {
-                            "install_components": ["linux_install"],
-                        }
-                    },
-                    "windows": {
-                        "cmake": {
-                            "install_components": ["win_install"],
-                        }
-                    }
-                }
-            }
-        }
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    opts.inherit_all(cfg)
-    pprint(cfg.to_dict())
-    opts.update_default_all(cfg)
-    pprint(cfg.to_dict())
-    assert cfg.to_dict() == {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    "module": {
-                        "name": "foobar",
-                        "directory": os.path.normpath("/project"),
-                    },
-                    "editable": {
-                        "mode": "wrapper",
-                    },
-                    "sdist": {
-                        "include": [],
-                        "exclude": [],
-                    },
-                    "cmake": {
-                        "build_type":
-                        "Release",
-                        "config": ["Release"],
-                        "generator":
-                        "Ninja",
-                        "source_path":
-                        os.path.normpath("/project/src"),
-                        "build_path":
-                        os.path.normpath("/project/.py-build-cmake_cache"),
-                        "options": {},
-                        "args": ["arg1", "arg2"],
-                        "find_python": False,
-                        "find_python3": True,
-                        "build_args": [],
-                        "build_tool_args": [],
-                        "install_args": [],
-                        "install_components": [""],
-                        "env": {
-                            "foo": "bar"
-                        },
-                    },
-                    "linux": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                        "cmake": {
-                            "build_type":
-                            "Release",
-                            "config": ["Release"],
-                            "generator":
-                            "Ninja",
-                            "source_path":
-                            os.path.normpath("/project/src"),
-                            "build_path":
-                            os.path.normpath("/project/.py-build-cmake_cache"),
-                            "options": {},
-                            "args": ["arg1", "arg2"],
-                            "find_python": False,
-                            "find_python3": True,
-                            "build_args": [],
-                            "build_tool_args": [],
-                            "install_args": [],
-                            "install_components": ["linux_install"],
-                            "env": {
-                                "foo": "bar"
-                            },
-                        },
-                    },
-                    "windows": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                        "cmake": {
-                            "build_type":
-                            "Release",
-                            "config": ["Release"],
-                            "generator":
-                            "Ninja",
-                            "source_path":
-                            os.path.normpath("/project/src"),
-                            "build_path":
-                            os.path.normpath("/project/.py-build-cmake_cache"),
-                            "options": {},
-                            "args": ["arg1", "arg2"],
-                            "find_python": False,
-                            "find_python3": True,
-                            "build_args": [],
-                            "build_tool_args": [],
-                            "install_args": [],
-                            "install_components": ["win_install"],
-                            "env": {
-                                "foo": "bar"
-                            },
-                        }
-                    },
-                    "mac": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                        "cmake": {
-                            "build_type":
-                            "Release",
-                            "config": ["Release"],
-                            "generator":
-                            "Ninja",
-                            "source_path":
-                            os.path.normpath("/project/src"),
-                            "build_path":
-                            os.path.normpath("/project/.py-build-cmake_cache"),
-                            "options": {},
-                            "args": ["arg1", "arg2"],
-                            "find_python": False,
-                            "find_python3": True,
-                            "build_args": [],
-                            "build_tool_args": [],
-                            "install_args": [],
-                            "install_components": [""],
-                            "env": {
-                                "foo": "bar"
-                            },
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-
-def test_real_config_no_cmake():
-    opts = get_options(Path('/project'), test=True)
-    d = {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {}
-            }
-        }
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    opts.inherit_all(cfg)
-    pprint(cfg.to_dict())
-    opts.update_default_all(cfg)
-    pprint(cfg.to_dict())
-    assert cfg.to_dict() == {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    "module": {
-                        "name": "foobar",
-                        "directory": os.path.normpath("/project"),
-                    },
-                    "editable": {
-                        "mode": "wrapper",
-                    },
-                    "sdist": {
-                        "include": [],
-                        "exclude": [],
-                    },
-                    "linux": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                    },
-                    "windows": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                    },
-                    "mac": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                    },
-                }
-            }
-        }
-    }
-
-
-def test_real_config_local_override():
-    opts = get_options(Path('/project'), test=True)
-    d = {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {}
-            }
-        },
-        "py-build-cmake.local.toml": {
-            "sdist": {
-                "include": ["somefile*"]
-            }
-        }
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    opts.override_all(cfg)
-    opts.inherit_all(cfg)
-    pprint(cfg.to_dict())
-    opts.update_default_all(cfg)
-    pprint(cfg.to_dict())
-    assert cfg.to_dict() == {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    "module": {
-                        "name": "foobar",
-                        "directory": os.path.normpath("/project"),
-                    },
-                    "editable": {
-                        "mode": "wrapper",
-                    },
-                    "sdist": {
-                        "include": ["somefile*"],
-                        "exclude": [],
-                    },
-                    "linux": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": ["somefile*"],
-                            "exclude": [],
-                        },
-                    },
-                    "windows": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": ["somefile*"],
-                            "exclude": [],
-                        },
-                    },
-                    "mac": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": ["somefile*"],
-                            "exclude": [],
-                        },
-                    },
-                }
-            }
-        },
-        "py-build-cmake.local.toml": {
-            "sdist": {
-                "include": ["somefile*"]
-            }
-        }
-    }
-
-
-def test_real_config_local_override_windows():
-    opts = get_options(Path('/project'), test=True)
-    d = {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    # "editable":{},
-                    # "sdist":{},
-                }
-            }
-        },
-        "py-build-cmake.local.toml": {
-            "windows": {
-                "editable": {
-                    "mode": "hook",
-                },
-                "sdist": {
-                    "include": ["somefile*"]
-                },
-            }
-        }
-    }
-    cfg = co.ConfigNode.from_dict(d)
-    opts.verify_all(cfg)
-    opts.override_all(cfg)
-    opts.inherit_all(cfg)
-    pprint(cfg.to_dict())
-    opts.update_default_all(cfg)
-    pprint(cfg.to_dict())
-    assert cfg.to_dict() == {
-        "pyproject.toml": {
-            "project": {
-                "name": "foobar"
-            },
-            "tool": {
-                "some-other-tool": {},
-                "py-build-cmake": {
-                    "module": {
-                        "name": "foobar",
-                        "directory": os.path.normpath("/project"),
-                    },
-                    "editable": {
-                        "mode": "wrapper",
-                    },
-                    "sdist": {
-                        "include": [],
-                        "exclude": [],
-                    },
-                    "linux": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                    },
-                    "windows": {
-                        "editable": {
-                            "mode": "hook",
-                        },
-                        "sdist": {
-                            "include": ["somefile*"],
-                            "exclude": [],
-                        },
-                    },
-                    "mac": {
-                        "editable": {
-                            "mode": "wrapper",
-                        },
-                        "sdist": {
-                            "include": [],
-                            "exclude": [],
-                        },
-                    },
-                }
-            }
-        },
-        "py-build-cmake.local.toml": {
-            "windows": {
-                "editable": {
-                    "mode": "hook",
-                },
-                "sdist": {
-                    "include": ["somefile*"]
-                }
-            }
-        }
-    }
-
-
-if __name__ == '__main__':
-    test_real_config_inherit_cross_cmake()
\ No newline at end of file
diff --git a/tests/expected_contents/bare-c-module/sdist.txt b/tests/expected_contents/bare-c-module/sdist.txt
new file mode 100644
index 0000000..af1f5a5
--- /dev/null
+++ b/tests/expected_contents/bare-c-module/sdist.txt
@@ -0,0 +1,6 @@
+bare_c_module-{{version}}/CMakeLists.txt
+bare_c_module-{{version}}/LICENSE
+bare_c_module-{{version}}/PKG-INFO
+bare_c_module-{{version}}/README.md
+bare_c_module-{{version}}/pyproject.toml
+bare_c_module-{{version}}/add_module.c
\ No newline at end of file
diff --git a/tests/expected_contents/bare-c-module/whl.txt b/tests/expected_contents/bare-c-module/whl.txt
new file mode 100644
index 0000000..ed539ef
--- /dev/null
+++ b/tests/expected_contents/bare-c-module/whl.txt
@@ -0,0 +1,6 @@
+bare_c_module-{{version}}.dist-info/LICENSE
+bare_c_module-{{version}}.dist-info/METADATA
+bare_c_module-{{version}}.dist-info/RECORD
+bare_c_module-{{version}}.dist-info/WHEEL
+bare_c_module-{{version}}.dist-info/entry_points.txt
+bare_c_module{{ext_suffix}}
\ No newline at end of file
diff --git a/tests/expected_contents/cmake-options/sdist.txt b/tests/expected_contents/cmake-options/sdist.txt
new file mode 100644
index 0000000..e937808
--- /dev/null
+++ b/tests/expected_contents/cmake-options/sdist.txt
@@ -0,0 +1,5 @@
+cmake_options-{{version}}/CMakeLists.txt
+cmake_options-{{version}}/LICENSE
+cmake_options-{{version}}/PKG-INFO
+cmake_options-{{version}}/README.md
+cmake_options-{{version}}/pyproject.toml
\ No newline at end of file
diff --git a/tests/expected_contents/cmake-options/whl.txt b/tests/expected_contents/cmake-options/whl.txt
new file mode 100644
index 0000000..69075ab
--- /dev/null
+++ b/tests/expected_contents/cmake-options/whl.txt
@@ -0,0 +1,6 @@
+cmake_options-{{version}}.dist-info/LICENSE
+cmake_options-{{version}}.dist-info/METADATA
+cmake_options-{{version}}.dist-info/RECORD
+cmake_options-{{version}}.dist-info/WHEEL
+cmake_options-{{version}}.dist-info/entry_points.txt
+cmake_options/__init__.py
\ No newline at end of file
diff --git a/tests/expected_contents/cmake-preset/sdist.txt b/tests/expected_contents/cmake-preset/sdist.txt
new file mode 100644
index 0000000..83e8ae1
--- /dev/null
+++ b/tests/expected_contents/cmake-preset/sdist.txt
@@ -0,0 +1,7 @@
+cmake_preset-{{version}}/CMakeLists.txt
+cmake_preset-{{version}}/LICENSE
+cmake_preset-{{version}}/PKG-INFO
+cmake_preset-{{version}}/README.md
+cmake_preset-{{version}}/pyproject.toml
+cmake_preset-{{version}}/generate.py
+cmake_preset-{{version}}/CMakePresets.json
\ No newline at end of file
diff --git a/tests/expected_contents/cmake-preset/whl.txt b/tests/expected_contents/cmake-preset/whl.txt
new file mode 100644
index 0000000..17a916e
--- /dev/null
+++ b/tests/expected_contents/cmake-preset/whl.txt
@@ -0,0 +1,6 @@
+cmake_preset-{{version}}.dist-info/LICENSE
+cmake_preset-{{version}}.dist-info/METADATA
+cmake_preset-{{version}}.dist-info/RECORD
+cmake_preset-{{version}}.dist-info/WHEEL
+cmake_preset-{{version}}.dist-info/entry_points.txt
+cmake_preset/__init__.py
\ No newline at end of file
diff --git a/tests/expected_contents/local-options/sdist.txt b/tests/expected_contents/local-options/sdist.txt
new file mode 100644
index 0000000..e937808
--- /dev/null
+++ b/tests/expected_contents/local-options/sdist.txt
@@ -0,0 +1,5 @@
+cmake_options-{{version}}/CMakeLists.txt
+cmake_options-{{version}}/LICENSE
+cmake_options-{{version}}/PKG-INFO
+cmake_options-{{version}}/README.md
+cmake_options-{{version}}/pyproject.toml
\ No newline at end of file
diff --git a/tests/expected_contents/local-options/whl.txt b/tests/expected_contents/local-options/whl.txt
new file mode 100644
index 0000000..69075ab
--- /dev/null
+++ b/tests/expected_contents/local-options/whl.txt
@@ -0,0 +1,6 @@
+cmake_options-{{version}}.dist-info/LICENSE
+cmake_options-{{version}}.dist-info/METADATA
+cmake_options-{{version}}.dist-info/RECORD
+cmake_options-{{version}}.dist-info/WHEEL
+cmake_options-{{version}}.dist-info/entry_points.txt
+cmake_options/__init__.py
\ No newline at end of file
diff --git a/tests/expected_contents/minimal-comp-debug/whl.txt b/tests/expected_contents/minimal-comp-debug/whl.txt
new file mode 100644
index 0000000..9565f34
--- /dev/null
+++ b/tests/expected_contents/minimal-comp-debug/whl.txt
@@ -0,0 +1,8 @@
+{% if sys.platform in ("linux", "win32") %}
+minimal_comp/_add_module{{dbg_suffix}}
+{% endif %}
+minimal_comp_debug-{{version}}.dist-info/LICENSE
+minimal_comp_debug-{{version}}.dist-info/METADATA
+minimal_comp_debug-{{version}}.dist-info/RECORD
+minimal_comp_debug-{{version}}.dist-info/WHEEL
+minimal_comp_debug-{{version}}.dist-info/entry_points.txt
\ No newline at end of file
diff --git a/tests/expected_contents/minimal-comp/whl.txt b/tests/expected_contents/minimal-comp/whl.txt
new file mode 100644
index 0000000..8fa8c32
--- /dev/null
+++ b/tests/expected_contents/minimal-comp/whl.txt
@@ -0,0 +1,14 @@
+minimal_comp-{{version}}.dist-info/LICENSE
+minimal_comp-{{version}}.dist-info/METADATA
+minimal_comp-{{version}}.dist-info/RECORD
+minimal_comp-{{version}}.dist-info/WHEEL
+minimal_comp-{{version}}.dist-info/entry_points.txt
+minimal_comp/__init__.py
+minimal_comp/_add_module{{ext_suffix}}
+minimal_comp/_add_module.pyi
+minimal_comp/add_module.py
+minimal_comp/py.typed
+{% if sys.implementation.name != 'pypy' or sys.version_info >= (3, 8) %}
+minimal_comp/__init__.pyi
+minimal_comp/add_module.pyi
+{% endif %}
\ No newline at end of file
diff --git a/tests/expected_contents/minimal-program/sdist.txt b/tests/expected_contents/minimal-program/sdist.txt
new file mode 100644
index 0000000..2e77537
--- /dev/null
+++ b/tests/expected_contents/minimal-program/sdist.txt
@@ -0,0 +1,8 @@
+minimal_program-{{version}}/CMakeLists.txt
+minimal_program-{{version}}/LICENSE
+minimal_program-{{version}}/PKG-INFO
+minimal_program-{{version}}/README.md
+minimal_program-{{version}}/pyproject.toml
+minimal_program-{{version}}/src-python/minimal_program_module/__init__.py
+minimal_program-{{version}}/src/CMakeLists.txt
+minimal_program-{{version}}/src/minimal_program.cpp
\ No newline at end of file
diff --git a/tests/expected_contents/minimal-program/whl.txt b/tests/expected_contents/minimal-program/whl.txt
new file mode 100644
index 0000000..3a8e13d
--- /dev/null
+++ b/tests/expected_contents/minimal-program/whl.txt
@@ -0,0 +1,7 @@
+minimal_program-{{version}}.data/scripts/minimal_program{{exe_suffix}}
+minimal_program-{{version}}.dist-info/LICENSE
+minimal_program-{{version}}.dist-info/METADATA
+minimal_program-{{version}}.dist-info/RECORD
+minimal_program-{{version}}.dist-info/WHEEL
+minimal_program-{{version}}.dist-info/entry_points.txt
+minimal_program_module/__init__.py
\ No newline at end of file
diff --git a/tests/expected_contents/minimal/sdist.txt b/tests/expected_contents/minimal/sdist.txt
new file mode 100644
index 0000000..b6e4e62
--- /dev/null
+++ b/tests/expected_contents/minimal/sdist.txt
@@ -0,0 +1,11 @@
+minimal-{{version}}/CMakeLists.txt
+minimal-{{version}}/LICENSE
+minimal-{{version}}/PKG-INFO
+minimal-{{version}}/README.md
+minimal-{{version}}/pyproject.toml
+minimal-{{version}}/src-python/minimal/__init__.py
+minimal-{{version}}/src-python/minimal/add_module.py
+minimal-{{version}}/src-python/minimal/py.typed
+minimal-{{version}}/src/CMakeLists.txt
+minimal-{{version}}/src/_add_module.pyi
+minimal-{{version}}/src/add_module.c
\ No newline at end of file
diff --git a/tests/expected_contents/minimal/whl.txt b/tests/expected_contents/minimal/whl.txt
new file mode 100644
index 0000000..0249b6d
--- /dev/null
+++ b/tests/expected_contents/minimal/whl.txt
@@ -0,0 +1,14 @@
+minimal-{{version}}.dist-info/LICENSE
+minimal-{{version}}.dist-info/METADATA
+minimal-{{version}}.dist-info/RECORD
+minimal-{{version}}.dist-info/WHEEL
+minimal-{{version}}.dist-info/entry_points.txt
+minimal/__init__.py
+minimal/_add_module{{ext_suffix}}
+minimal/_add_module.pyi
+minimal/add_module.py
+minimal/py.typed
+{% if sys.implementation.name != 'pypy' or sys.version_info >= (3, 8) %}
+minimal/__init__.pyi
+minimal/add_module.pyi
+{% endif %}
\ No newline at end of file
diff --git a/tests/expected_contents/namespace-project-a/sdist.txt b/tests/expected_contents/namespace-project-a/sdist.txt
new file mode 100644
index 0000000..627c7af
--- /dev/null
+++ b/tests/expected_contents/namespace-project-a/sdist.txt
@@ -0,0 +1,11 @@
+namespace_project_a-{{version}}/CMakeLists.txt
+namespace_project_a-{{version}}/LICENSE
+namespace_project_a-{{version}}/PKG-INFO
+namespace_project_a-{{version}}/README.md
+namespace_project_a-{{version}}/cmake/Pybind11Stubgen.cmake
+namespace_project_a-{{version}}/cmake/QueryPythonForPybind11.cmake
+namespace_project_a-{{version}}/cmake/Reproducible.cmake
+namespace_project_a-{{version}}/pyproject.toml
+namespace_project_a-{{version}}/python-src/namespace_project/add_module.py
+namespace_project_a-{{version}}/python-src/namespace_project/py.typed
+namespace_project_a-{{version}}/src/add_module.cpp
\ No newline at end of file
diff --git a/tests/expected_contents/namespace-project-a/whl.txt b/tests/expected_contents/namespace-project-a/whl.txt
new file mode 100644
index 0000000..310ab98
--- /dev/null
+++ b/tests/expected_contents/namespace-project-a/whl.txt
@@ -0,0 +1,12 @@
+namespace_project_a-{{version}}.dist-info/LICENSE
+namespace_project_a-{{version}}.dist-info/METADATA
+namespace_project_a-{{version}}.dist-info/RECORD
+namespace_project_a-{{version}}.dist-info/WHEEL
+namespace_project_a-{{version}}.dist-info/entry_points.txt
+namespace_project/_add_module{{ext_suffix}}
+namespace_project/_add_module.pyi
+namespace_project/add_module.py
+namespace_project/py.typed
+{% if sys.implementation.name != 'pypy' or sys.version_info >= (3, 8) %}
+namespace_project/add_module.pyi
+{% endif %}
\ No newline at end of file
diff --git a/tests/expected_contents/namespace-project-b/sdist.txt b/tests/expected_contents/namespace-project-b/sdist.txt
new file mode 100644
index 0000000..7b09ea5
--- /dev/null
+++ b/tests/expected_contents/namespace-project-b/sdist.txt
@@ -0,0 +1,6 @@
+namespace_project_b-{{version}}/LICENSE
+namespace_project_b-{{version}}/PKG-INFO
+namespace_project_b-{{version}}/README.md
+namespace_project_b-{{version}}/pyproject.toml
+namespace_project_b-{{version}}/python-src/namespace_project/sub_module.py
+namespace_project_b-{{version}}/python-src/namespace_project/py.typed
\ No newline at end of file
diff --git a/tests/expected_contents/namespace-project-b/whl.txt b/tests/expected_contents/namespace-project-b/whl.txt
new file mode 100644
index 0000000..a2f2081
--- /dev/null
+++ b/tests/expected_contents/namespace-project-b/whl.txt
@@ -0,0 +1,10 @@
+namespace_project_b-{{version}}.dist-info/LICENSE
+namespace_project_b-{{version}}.dist-info/METADATA
+namespace_project_b-{{version}}.dist-info/RECORD
+namespace_project_b-{{version}}.dist-info/WHEEL
+namespace_project_b-{{version}}.dist-info/entry_points.txt
+namespace_project/sub_module.py
+namespace_project/py.typed
+{% if sys.implementation.name != 'pypy' or sys.version_info >= (3, 8) %}
+namespace_project/sub_module.pyi
+{% endif %}
\ No newline at end of file
diff --git a/tests/expected_contents/nanobind-project/sdist.txt b/tests/expected_contents/nanobind-project/sdist.txt
new file mode 100644
index 0000000..e56b9be
--- /dev/null
+++ b/tests/expected_contents/nanobind-project/sdist.txt
@@ -0,0 +1,13 @@
+nanobind_project-{{version}}/CMakeLists.txt
+nanobind_project-{{version}}/LICENSE
+nanobind_project-{{version}}/PKG-INFO
+nanobind_project-{{version}}/README.md
+nanobind_project-{{version}}/cmake/QueryPythonForNanobind.cmake
+nanobind_project-{{version}}/cmake/nanobindGuessPythonExtSuffix.cmake
+nanobind_project-{{version}}/pyproject.toml
+nanobind_project-{{version}}/python-src/nanobind_project/__init__.py
+nanobind_project-{{version}}/python-src/nanobind_project/add.py
+nanobind_project-{{version}}/python-src/nanobind_project/add_module.py
+nanobind_project-{{version}}/python-src/nanobind_project/py.typed
+nanobind_project-{{version}}/python-src/nanobind_project/sub_package/__init__.py
+nanobind_project-{{version}}/src/add_module.cpp
\ No newline at end of file
diff --git a/tests/expected_contents/nanobind-project/whl.txt b/tests/expected_contents/nanobind-project/whl.txt
new file mode 100644
index 0000000..16211cf
--- /dev/null
+++ b/tests/expected_contents/nanobind-project/whl.txt
@@ -0,0 +1,20 @@
+nanobind_project-{{version}}.dist-info/LICENSE
+nanobind_project-{{version}}.dist-info/METADATA
+nanobind_project-{{version}}.dist-info/RECORD
+nanobind_project-{{version}}.dist-info/WHEEL
+nanobind_project-{{version}}.dist-info/entry_points.txt
+nanobind_project/__init__.py
+nanobind_project/_add_module{{ext_suffix}}
+nanobind_project/_add_module.pyi
+nanobind_project/_add_module_d{{ext_suffix}}
+nanobind_project/_add_module_d.pyi
+nanobind_project/add.py
+nanobind_project/add_module.py
+nanobind_project/py.typed
+nanobind_project/sub_package/__init__.py
+{% if sys.implementation.name != 'pypy' or sys.version_info >= (3, 8) %}
+nanobind_project/__init__.pyi
+nanobind_project/add.pyi
+nanobind_project/add_module.pyi
+nanobind_project/sub_package/__init__.pyi
+{% endif %}
\ No newline at end of file
diff --git a/tests/expected_contents/pybind11-project/sdist.txt b/tests/expected_contents/pybind11-project/sdist.txt
new file mode 100644
index 0000000..3ae9f09
--- /dev/null
+++ b/tests/expected_contents/pybind11-project/sdist.txt
@@ -0,0 +1,13 @@
+pybind11_project-{{version}}/CMakeLists.txt
+pybind11_project-{{version}}/LICENSE
+pybind11_project-{{version}}/PKG-INFO
+pybind11_project-{{version}}/README.md
+pybind11_project-{{version}}/cmake/Pybind11Stubgen.cmake
+pybind11_project-{{version}}/cmake/QueryPythonForPybind11.cmake
+pybind11_project-{{version}}/pyproject.toml
+pybind11_project-{{version}}/python-src/pybind11_project/__init__.py
+pybind11_project-{{version}}/python-src/pybind11_project/add.py
+pybind11_project-{{version}}/python-src/pybind11_project/add_module.py
+pybind11_project-{{version}}/python-src/pybind11_project/py.typed
+pybind11_project-{{version}}/python-src/pybind11_project/sub_package/__init__.py
+pybind11_project-{{version}}/src/add_module.cpp
\ No newline at end of file
diff --git a/tests/expected_contents/pybind11-project/whl.txt b/tests/expected_contents/pybind11-project/whl.txt
new file mode 100644
index 0000000..329b37b
--- /dev/null
+++ b/tests/expected_contents/pybind11-project/whl.txt
@@ -0,0 +1,20 @@
+pybind11_project-{{version}}.dist-info/LICENSE
+pybind11_project-{{version}}.dist-info/METADATA
+pybind11_project-{{version}}.dist-info/RECORD
+pybind11_project-{{version}}.dist-info/WHEEL
+pybind11_project-{{version}}.dist-info/entry_points.txt
+pybind11_project/__init__.py
+pybind11_project/_add_module{{ext_suffix}}
+pybind11_project/_add_module.pyi
+pybind11_project/_add_module_d{{ext_suffix}}
+pybind11_project/_add_module_d.pyi
+pybind11_project/add.py
+pybind11_project/add_module.py
+pybind11_project/py.typed
+pybind11_project/sub_package/__init__.py
+{% if sys.implementation.name != 'pypy' or sys.version_info >= (3, 8) %}
+pybind11_project/__init__.pyi
+pybind11_project/add.pyi
+pybind11_project/add_module.pyi
+pybind11_project/sub_package/__init__.pyi
+{% endif %}
\ No newline at end of file
diff --git a/tests/test_cli_override.py b/tests/test_cli_override.py
new file mode 100644
index 0000000..cbc2196
--- /dev/null
+++ b/tests/test_cli_override.py
@@ -0,0 +1,69 @@
+from py_build_cmake.config.cli_override import CLIOption, parse_cli, parse_file
+
+
+def test_parse_cli():
+
+    assert parse_cli(
+        r'tools.py-build-cmake.cmake."😄"-=[a, b, c, def, 551, False]'
+    ) == CLIOption(
+        action="-=",
+        key=("tools", "py-build-cmake", "cmake", "😄"),
+        value=["a", "b", "c", "def", 551, False],
+    )
+    assert parse_cli(r'"a b c\\\""=!') == CLIOption(
+        action="=!",
+        key=('a b c\\"',),
+        value=None,
+    )
+    assert parse_cli(r'"a b c"=+ foo=5 ') == CLIOption(
+        action="=+",
+        key=("a b c",),
+        value=" foo=5 ",
+    )
+
+
+def test_parse_file():
+    file = r"""
+            "a b c"    =+foo=5
+            y= d, e, f# Comment
+            z= a, b, c    # Comment
+        tools.py-build-cmake.cmake."😄"-=[a, b, c, def, 551, False]
+        a.b.c=!   # Comment
+        bar  ={a = 1, b= 2, c =3, d=4, e=foo=5, f= foo=5, g = foo=5 }
+        zed -=[]
+        zed -=[1]
+        zed -=[1, 2]   # Comment
+        zed -=[1, 2,]
+# Foo bar
+        # Bar foo
+        baz+=(path)$HOME/opt/python/bin
+        """
+    assert parse_file(file) == [
+        CLIOption(action="=+", key=("a b c",), value="foo=5"),
+        CLIOption(action="=", key=("y",), value=" d, e, f"),
+        CLIOption(action="=", key=("z",), value=" a, b, c    "),
+        CLIOption(
+            action="-=",
+            key=("tools", "py-build-cmake", "cmake", "😄"),
+            value=["a", "b", "c", "def", 551, False],
+        ),
+        CLIOption(action="=!", key=("a", "b", "c"), value=None),
+        CLIOption(
+            action="=",
+            key=("bar",),
+            value={
+                "a": 1,
+                "b": 2,
+                "c": 3,
+                "d": 4,
+                "e": "foo=5",
+                "f": "foo=5",
+                "g": "foo=5",
+            },
+        ),
+        CLIOption(action="-=", key=("zed",), value=[]),
+        CLIOption(action="-=", key=("zed",), value=[1]),
+        CLIOption(action="-=", key=("zed",), value=[1, 2]),
+        CLIOption(action="-=", key=("zed",), value=[1, 2]),
+        CLIOption(action="+=(path)", key=("baz",), value="$HOME/opt/python/bin"),
+    ]
diff --git a/tests/test_config_load.py b/tests/test_config_load.py
new file mode 100644
index 0000000..fcf14dc
--- /dev/null
+++ b/tests/test_config_load.py
@@ -0,0 +1,653 @@
+import os
+from pathlib import PurePosixPath
+
+import pytest
+from py_build_cmake.config.cli_override import parse_file
+from py_build_cmake.config.load import (
+    Config,
+    ConfigError,
+    add_cli_override,
+    process_config,
+)
+from py_build_cmake.config.options.config_path import ConfPath
+
+
+def test_process_config_no_cmake():
+    pyproj_path = PurePosixPath("/project/pyproject.toml")
+    pyproj = {
+        "project": {"name": "foobar", "version": "0.0.1"},
+        "tool": {"some-other-tool": {}, "py-build-cmake": {}},
+    }
+    files = {"pyproject.toml": pyproj}
+    cfg: Config = process_config(pyproj_path, files, {}, test=True)
+    assert not cfg.cmake
+    assert not cfg.cross
+    assert not cfg.stubgen
+    assert cfg.package_name == "foobar"
+    assert cfg.module["name"] == "foobar"
+    assert cfg.module["directory"] == PurePosixPath("/project")
+    assert not cfg.module["namespace"]
+
+
+def test_process_config_no_cmake_namespace_wrong_editable_mode():
+    pyproj_path = PurePosixPath("/project/pyproject.toml")
+    pyproj = {
+        "project": {"name": "foobar", "version": "0.0.1"},
+        "tool": {
+            "some-other-tool": {},
+            "py-build-cmake": {
+                "module": {"namespace": True},
+                "editable": {"build_hook": False, "mode": "wrapper"},
+            },
+        },
+    }
+    files = {"pyproject.toml": pyproj}
+    expected = "^Namespace packages cannot use editable mode 'wrapper'$"
+    with pytest.raises(ConfigError, match=expected):
+        process_config(pyproj_path, files, {}, test=True)
+
+
+def test_inherit_cross_cmake():
+    pyproj_path = PurePosixPath("/project/pyproject.toml")
+    pyproj = {
+        "project": {"name": "foobar", "version": "1.2.3", "description": "descr"},
+        "tool": {
+            "some-other-tool": {},
+            "py-build-cmake": {
+                "cmake": {
+                    "build_type": "Release",
+                    "generator": "Ninja",
+                    "source_path": "src",
+                    "env": {"foo": "bar"},
+                    "args": ["arg1", "arg2"],
+                    "find_python": False,
+                    "find_python3": True,
+                    "install_components": ["all_install"],
+                },
+                "cross": {
+                    "implementation": "cp",
+                    "version": "310",
+                    "abi": "cp310",
+                    "arch": "linux_aarch64",
+                    "toolchain_file": "aarch64-linux-gnu.cmake",
+                    "cmake": {
+                        "generator": "Unix Makefiles",
+                        "build_type": "RelWithDebInfo",
+                        "env": {"crosscompiling": "true"},
+                        "args": ["arg3", "arg4"],
+                    },
+                },
+                "linux": {
+                    "cmake": {
+                        "args": ["linux_arg"],
+                        "install_components": ["linux_install"],
+                    }
+                },
+                "windows": {
+                    "cmake": {
+                        "args": {
+                            "-": ["arg1"],
+                            "prepend": ["win_arg"],
+                            "+": ["arg1"],
+                        },
+                        "install_components": {"+": ["win_install"]},
+                    }
+                },
+            },
+        },
+    }
+    files = {"pyproject.toml": pyproj}
+    conf = process_config(pyproj_path, files, {}, test=True)
+    assert conf.standard_metadata.name == "foobar"
+    assert str(conf.standard_metadata.version) == "1.2.3"
+    assert conf.standard_metadata.description == "descr"
+    assert conf.module == {
+        "name": "foobar",
+        "directory": PurePosixPath("/project"),
+        "namespace": False,
+    }
+    assert conf.editable == {
+        "cross": {"build_hook": False, "mode": "symlink"},
+        "linux": {"build_hook": False, "mode": "symlink"},
+        "windows": {"build_hook": False, "mode": "symlink"},
+        "mac": {"build_hook": False, "mode": "symlink"},
+    }
+    assert conf.sdist == {
+        "cross": {"include_patterns": [], "exclude_patterns": []},
+        "linux": {"include_patterns": [], "exclude_patterns": []},
+        "windows": {"include_patterns": [], "exclude_patterns": []},
+        "mac": {"include_patterns": [], "exclude_patterns": []},
+    }
+    assert conf.cmake == {
+        "cross": {
+            "0": {
+                "build_type": "RelWithDebInfo",
+                "config": ["RelWithDebInfo"],
+                "generator": "Unix Makefiles",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": ["arg1", "arg2", "arg3", "arg4"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": [],
+                "install_config": ["RelWithDebInfo"],
+                "install_args": [],
+                "install_components": ["all_install"],
+                "minimum_version": "3.15",
+                "env": {
+                    "foo": "bar",
+                    "crosscompiling": "true",
+                },
+            },
+        },
+        "linux": {
+            "0": {
+                "build_type": "Release",
+                "config": ["Release"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": ["arg1", "arg2", "linux_arg"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": [],
+                "install_config": ["Release"],
+                "install_args": [],
+                "install_components": ["linux_install"],
+                "minimum_version": "3.15",
+                "env": {"foo": "bar"},
+            },
+        },
+        "windows": {
+            "0": {
+                "build_type": "Release",
+                "config": ["Release"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": ["win_arg", "arg2", "arg1"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": [],
+                "install_config": ["Release"],
+                "install_args": [],
+                "install_components": ["all_install", "win_install"],
+                "minimum_version": "3.15",
+                "env": {"foo": "bar"},
+            }
+        },
+        "mac": {
+            "0": {
+                "build_type": "Release",
+                "config": ["Release"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": ["arg1", "arg2"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": [],
+                "install_config": ["Release"],
+                "install_args": [],
+                "install_components": ["all_install"],
+                "minimum_version": "3.15",
+                "env": {"foo": "bar"},
+            }
+        },
+    }
+    assert conf.wheel == {
+        "cross": {
+            "python_tag": ["auto"],
+            "python_abi": "auto",
+            "abi3_minimum_cpython_version": 32,
+        },
+        "linux": {
+            "python_tag": ["auto"],
+            "python_abi": "auto",
+            "abi3_minimum_cpython_version": 32,
+        },
+        "windows": {
+            "python_tag": ["auto"],
+            "python_abi": "auto",
+            "abi3_minimum_cpython_version": 32,
+        },
+        "mac": {
+            "python_tag": ["auto"],
+            "python_abi": "auto",
+            "abi3_minimum_cpython_version": 32,
+        },
+    }
+    assert conf.cross == {
+        "implementation": "cp",
+        "version": "310",
+        "abi": "cp310",
+        "arch": "linux_aarch64",
+        "toolchain_file": PurePosixPath("/project/aarch64-linux-gnu.cmake"),
+    }
+
+
+def test_real_config_no_cross():
+    pyproj_path = PurePosixPath("/project/pyproject.toml")
+    pyproj = {
+        "project": {"name": "foobar", "version": "1.2.3", "description": "descr"},
+        "tool": {
+            "some-other-tool": {},
+            "py-build-cmake": {
+                "cmake": {
+                    "build_type": "Release",
+                    "generator": "Ninja",
+                    "source_path": "src",
+                    "env": {"foo": "bar"},
+                    "args": ["arg1", "arg2"],
+                    "find_python": False,
+                    "find_python3": True,
+                },
+                "linux": {
+                    "cmake": {
+                        "install_components": ["linux_install"],
+                    }
+                },
+                "windows": {
+                    "cmake": {
+                        "install_components": ["win_install"],
+                    }
+                },
+            },
+        },
+    }
+    files = {"pyproject.toml": pyproj}
+    conf = process_config(pyproj_path, files, {}, test=True)
+    assert conf.standard_metadata.name == "foobar"
+    assert str(conf.standard_metadata.version) == "1.2.3"
+    assert conf.standard_metadata.description == "descr"
+    assert conf.module == {
+        "name": "foobar",
+        "directory": PurePosixPath("/project"),
+        "namespace": False,
+    }
+    assert conf.editable == {
+        "linux": {"build_hook": False, "mode": "symlink"},
+        "windows": {"build_hook": False, "mode": "symlink"},
+        "mac": {"build_hook": False, "mode": "symlink"},
+    }
+    assert conf.sdist == {
+        "linux": {"include_patterns": [], "exclude_patterns": []},
+        "windows": {"include_patterns": [], "exclude_patterns": []},
+        "mac": {"include_patterns": [], "exclude_patterns": []},
+    }
+    assert conf.cmake == {
+        "linux": {
+            "0": {
+                "build_type": "Release",
+                "config": ["Release"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": ["arg1", "arg2"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": [],
+                "install_config": ["Release"],
+                "install_args": [],
+                "install_components": ["linux_install"],
+                "minimum_version": "3.15",
+                "env": {"foo": "bar"},
+            }
+        },
+        "windows": {
+            "0": {
+                "build_type": "Release",
+                "config": ["Release"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": ["arg1", "arg2"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": [],
+                "install_config": ["Release"],
+                "install_args": [],
+                "install_components": ["win_install"],
+                "minimum_version": "3.15",
+                "env": {"foo": "bar"},
+            }
+        },
+        "mac": {
+            "0": {
+                "build_type": "Release",
+                "config": ["Release"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": ["arg1", "arg2"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": [],
+                "install_config": ["Release"],
+                "install_args": [],
+                "install_components": [""],
+                "minimum_version": "3.15",
+                "env": {"foo": "bar"},
+            },
+        },
+    }
+    assert conf.wheel == {
+        "linux": {
+            "python_tag": ["auto"],
+            "python_abi": "auto",
+            "abi3_minimum_cpython_version": 32,
+        },
+        "windows": {
+            "python_tag": ["auto"],
+            "python_abi": "auto",
+            "abi3_minimum_cpython_version": 32,
+        },
+        "mac": {
+            "python_tag": ["auto"],
+            "python_abi": "auto",
+            "abi3_minimum_cpython_version": 32,
+        },
+    }
+    assert conf.cross is None
+
+
+def test_real_config_no_cmake():
+    pyproj_path = PurePosixPath("/project/pyproject.toml")
+    pyproj = {
+        "project": {"name": "foobar", "version": "1.2.3", "description": "descr"},
+        "tool": {"some-other-tool": {}, "py-build-cmake": {}},
+    }
+    files = {"pyproject.toml": pyproj}
+    conf = process_config(pyproj_path, files, {}, test=True)
+    assert conf.standard_metadata.name == "foobar"
+    assert str(conf.standard_metadata.version) == "1.2.3"
+    assert conf.standard_metadata.description == "descr"
+    assert conf.module == {
+        "name": "foobar",
+        "directory": PurePosixPath("/project"),
+        "namespace": False,
+    }
+    assert conf.editable == {
+        "linux": {"build_hook": False, "mode": "symlink"},
+        "windows": {"build_hook": False, "mode": "symlink"},
+        "mac": {"build_hook": False, "mode": "symlink"},
+    }
+    assert conf.sdist == {
+        "linux": {"include_patterns": [], "exclude_patterns": []},
+        "windows": {"include_patterns": [], "exclude_patterns": []},
+        "mac": {"include_patterns": [], "exclude_patterns": []},
+    }
+    assert conf.cmake is None
+    assert conf.cross is None
+
+
+def test_real_config_local_override():
+    pyproj_path = PurePosixPath("/project/pyproject.toml")
+    pyproj = {
+        "project": {"name": "foobar", "version": "1.2.3", "description": "descr"},
+        "tool": {"some-other-tool": {}, "py-build-cmake": {}},
+    }
+    local = {
+        "sdist": {"include": ["somefile*"]},
+    }
+    files = {"pyproject.toml": pyproj, "/some/path/py-build-cmake.local.toml": local}
+    overrides = {
+        ConfPath(("/some/path/py-build-cmake.local.toml",)): ConfPath(
+            ("pyproject.toml", "tool", "py-build-cmake")
+        ),
+    }
+    conf = process_config(pyproj_path, files, overrides, test=True)
+    assert conf.standard_metadata.name == "foobar"
+    assert str(conf.standard_metadata.version) == "1.2.3"
+    assert conf.standard_metadata.description == "descr"
+    assert conf.module == {
+        "name": "foobar",
+        "directory": PurePosixPath("/project"),
+        "namespace": False,
+    }
+    assert conf.editable == {
+        "linux": {"build_hook": False, "mode": "symlink"},
+        "windows": {"build_hook": False, "mode": "symlink"},
+        "mac": {"build_hook": False, "mode": "symlink"},
+    }
+    assert conf.sdist == {
+        "linux": {"include_patterns": ["somefile*"], "exclude_patterns": []},
+        "windows": {"include_patterns": ["somefile*"], "exclude_patterns": []},
+        "mac": {"include_patterns": ["somefile*"], "exclude_patterns": []},
+    }
+    assert conf.cmake is None
+    assert conf.cross is None
+
+
+def test_real_config_local_override_windows():
+    pyproj_path = PurePosixPath("/project/pyproject.toml")
+    pyproj = {
+        "project": {"name": "foobar", "version": "1.2.3", "description": "descr"},
+        "tool": {"some-other-tool": {}, "py-build-cmake": {}},
+    }
+    local = {
+        "windows": {
+            "editable": {
+                "mode": "hook",
+            },
+            "sdist": {"include": ["somefile*"]},
+        }
+    }
+    files = {"pyproject.toml": pyproj, "/some/path/py-build-cmake.local.toml": local}
+    overrides = {
+        ConfPath(("/some/path/py-build-cmake.local.toml",)): ConfPath(
+            ("pyproject.toml", "tool", "py-build-cmake")
+        ),
+    }
+    conf = process_config(pyproj_path, files, overrides, test=True)
+    assert conf.standard_metadata.name == "foobar"
+    assert str(conf.standard_metadata.version) == "1.2.3"
+    assert conf.standard_metadata.description == "descr"
+    assert conf.module == {
+        "name": "foobar",
+        "directory": PurePosixPath("/project"),
+        "namespace": False,
+    }
+    assert conf.editable == {
+        "linux": {"build_hook": False, "mode": "symlink"},
+        "windows": {"build_hook": False, "mode": "hook"},
+        "mac": {"build_hook": False, "mode": "symlink"},
+    }
+    assert conf.sdist == {
+        "linux": {"include_patterns": [], "exclude_patterns": []},
+        "windows": {"include_patterns": ["somefile*"], "exclude_patterns": []},
+        "mac": {"include_patterns": [], "exclude_patterns": []},
+    }
+    assert conf.cmake is None
+    assert conf.cross is None
+
+
+def test_real_config_cli_override():
+    pyproj_path = PurePosixPath("/project/pyproject.toml")
+    pyproj = {
+        "project": {"name": "foobar", "version": "1.2.3", "description": "descr"},
+        "tool": {
+            "some-other-tool": {},
+            "py-build-cmake": {
+                "cmake": {
+                    "build_type": "Release",
+                    "generator": "Ninja",
+                    "source_path": "src",
+                    "env": {"foo": "bar"},
+                    "args": ["arg1", "arg2"],
+                    "build_tool_args": ["-a", "-b"],
+                    "find_python": False,
+                    "find_python3": True,
+                },
+                "wheel": {
+                    "python_abi": "abi3",
+                },
+                "linux": {
+                    "cmake": {
+                        "install_components": ["linux_install"],
+                        "env": {"PATH": "/usr/bin"},
+                        "args": ["arg3", "arg4"],
+                    }
+                },
+                "windows": {
+                    "cmake": {
+                        "install_components": ["win_install"],
+                    }
+                },
+            },
+        },
+    }
+    files = {"pyproject.toml": pyproj}
+    override_config = r"""
+        linux.cmake.build_type=MinSizeRel
+        linux.cmake.env.PATH=+(path)$HOME/opt
+        linux.cmake.options.FOOBAR="abc"
+        linux.cmake.options.FOOBAR+="def"
+        linux.cmake.options.FOOBAR+="ghi"
+        linux.cmake.options.FOOBAR=+"xyz"
+        linux.cmake.options.FOOBAR-="def"
+        linux.cmake.args-=["arg3"]
+        linux.wheel.python_abi=!
+        mac.wheel.python_abi="none"
+        mac.cmake.args=!
+        mac.cmake.env=!
+        mac.cmake.find_python=!
+        cmake.build_tool_args=["-c", "-d"]
+    """
+    overrides = {}
+    for i, opt in enumerate(parse_file(override_config)):
+        overrides.update(add_cli_override(files, opt, f"<cli:{i+1}>"))
+
+    conf = process_config(pyproj_path, files, overrides, test=True)
+    assert conf.standard_metadata.name == "foobar"
+    assert str(conf.standard_metadata.version) == "1.2.3"
+    assert conf.standard_metadata.description == "descr"
+    assert conf.module == {
+        "name": "foobar",
+        "directory": PurePosixPath("/project"),
+        "namespace": False,
+    }
+    assert conf.editable == {
+        "linux": {"build_hook": False, "mode": "symlink"},
+        "windows": {"build_hook": False, "mode": "symlink"},
+        "mac": {"build_hook": False, "mode": "symlink"},
+    }
+    assert conf.sdist == {
+        "linux": {"include_patterns": [], "exclude_patterns": []},
+        "windows": {"include_patterns": [], "exclude_patterns": []},
+        "mac": {"include_patterns": [], "exclude_patterns": []},
+    }
+    assert conf.cmake == {
+        "linux": {
+            "0": {
+                "build_type": "MinSizeRel",
+                "config": ["MinSizeRel"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {"FOOBAR": "xyz;abc;ghi"},
+                "args": ["arg1", "arg2", "arg4"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": ["-c", "-d"],
+                "install_config": ["MinSizeRel"],
+                "install_args": [],
+                "install_components": ["linux_install"],
+                "minimum_version": "3.15",
+                "env": {"PATH": "$HOME/opt" + os.pathsep + "/usr/bin", "foo": "bar"},
+            }
+        },
+        "windows": {
+            "0": {
+                "build_type": "Release",
+                "config": ["Release"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": ["arg1", "arg2"],
+                "find_python": False,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": ["-c", "-d"],
+                "install_config": ["Release"],
+                "install_args": [],
+                "install_components": ["win_install"],
+                "minimum_version": "3.15",
+                "env": {"foo": "bar"},
+            }
+        },
+        "mac": {
+            "0": {
+                "build_type": "Release",
+                "config": ["Release"],
+                "generator": "Ninja",
+                "source_path": PurePosixPath("/project/src"),
+                "build_path": PurePosixPath(
+                    "/project/.py-build-cmake_cache/{build_config}"
+                ),
+                "options": {},
+                "args": [],
+                "find_python": True,
+                "find_python3": True,
+                "build_args": [],
+                "build_tool_args": ["-c", "-d"],
+                "install_config": ["Release"],
+                "install_args": [],
+                "install_components": [""],
+                "minimum_version": "3.15",
+                "env": {},
+            },
+        },
+    }
+    assert conf.wheel == {
+        "linux": {
+            "python_tag": ["auto"],
+            "python_abi": "auto",
+            "abi3_minimum_cpython_version": 32,
+        },
+        "windows": {
+            "python_tag": ["auto"],
+            "python_abi": "abi3",
+            "abi3_minimum_cpython_version": 32,
+        },
+        "mac": {
+            "python_tag": ["auto"],
+            "python_abi": "none",
+            "abi3_minimum_cpython_version": 32,
+        },
+    }
+    assert conf.cross is None
diff --git a/tests/test_configoptions.py b/tests/test_configoptions.py
new file mode 100644
index 0000000..3335fc5
--- /dev/null
+++ b/tests/test_configoptions.py
@@ -0,0 +1,1189 @@
+from pprint import pprint
+from typing import Any
+
+import pytest
+from py_build_cmake.common import ConfigError
+from py_build_cmake.config.options.config_option import ConfigOption
+from py_build_cmake.config.options.config_path import ConfPath
+from py_build_cmake.config.options.config_reference import ConfigReference
+from py_build_cmake.config.options.default import (
+    ConfigDefaulter,
+    DefaultValueValue,
+    MissingDefaultError,
+    NoDefaultValue,
+    RefDefaultValue,
+    RequiredValue,
+)
+from py_build_cmake.config.options.dict import DictOfStrConfigOption
+from py_build_cmake.config.options.finalize import ConfigFinalizer
+from py_build_cmake.config.options.inherit import ConfigInheritor
+from py_build_cmake.config.options.list import ListOfStrConfigOption
+from py_build_cmake.config.options.override import ConfigOverrider
+from py_build_cmake.config.options.string import StringConfigOption
+from py_build_cmake.config.options.value_reference import (
+    OverrideAction,
+    OverrideActionEnum,
+    ValueReference,
+)
+from py_build_cmake.config.options.verify import ConfigVerifier
+
+
+def gen_test_opts():
+    leaf11 = StringConfigOption("leaf11")
+    leaf12 = StringConfigOption("leaf12")
+    mid1 = ConfigOption("mid1")
+    mid1.insert(leaf11)
+    mid1.insert(leaf12)
+    leaf21 = StringConfigOption("leaf21")
+    leaf22 = StringConfigOption("leaf22")
+    mid2 = ConfigOption("mid2")
+    mid2.insert(leaf21)
+    mid2.insert(leaf22)
+    trunk = ConfigOption("trunk")
+    trunk.insert(mid1)
+    trunk.insert(mid2)
+    opts = ConfigOption("root")
+    opts.insert(trunk)
+    return opts
+
+
+def test_update_defaults():
+    opts = gen_test_opts()
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    trunk = root_ref.sub_ref(ConfPath.from_string("trunk"))
+    assert trunk.config.name == "trunk"
+    mid1 = root_ref.sub_ref(ConfPath.from_string("trunk/mid1"))
+    assert mid1.config.name == "mid1"
+    leaf12 = root_ref.sub_ref(ConfPath.from_string("trunk/mid1/leaf12"))
+    assert leaf12.config.name == "leaf12"
+
+    values = {}
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    trunk.config.default = DefaultValueValue({})
+    rval.values = ConfigFinalizer(root=root_ref, ref=root_ref, values=rval).finalize()
+    ConfigDefaulter(root=root_ref, root_values=rval).update_default()
+    assert rval.values == {"trunk": {}}
+
+    values = {}
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    leaf12.config.default = DefaultValueValue("d12")
+    rval.values = ConfigFinalizer(root=root_ref, ref=root_ref, values=rval).finalize()
+    ConfigDefaulter(root=root_ref, root_values=rval).update_default()
+    assert rval.values == {"trunk": {}}
+
+    values = {}
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    mid1.config.default = DefaultValueValue({})
+    rval.values = ConfigFinalizer(root=root_ref, ref=root_ref, values=rval).finalize()
+    ConfigDefaulter(root=root_ref, root_values=rval).update_default()
+    assert rval.values == {"trunk": {"mid1": {"leaf12": "d12"}}}
+
+    values = {}
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    trunk.config.default = NoDefaultValue()
+    rval.values = ConfigFinalizer(root=root_ref, ref=root_ref, values=rval).finalize()
+    ConfigDefaulter(root=root_ref, root_values=rval).update_default()
+    assert rval.values == {}
+
+
+def test_override0():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {}  # No override
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+        new_values=ValueReference(ConfPath.from_string("/"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+
+
+def test_override1():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {"leaf21": "23"}
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref.sub_ref(ConfPath.from_string("trunk/mid2")),
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref.sub_ref(ConfPath.from_string("trunk/mid2")),
+        values=rval.sub_ref(ConfPath.from_string("trunk/mid2")),
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref.sub_ref(ConfPath.from_string("trunk/mid2")),
+        values=ValueReference(ConfPath.from_string("trunk/mid2"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "leaf21": "23",
+        "leaf22": "22",
+    }
+
+
+def test_override2():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {
+        "leaf21": "31",
+        "leaf22": "32",
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref.sub_ref(ConfPath.from_string("trunk/mid2")),
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref.sub_ref(ConfPath.from_string("trunk/mid2")),
+        values=rval.sub_ref(ConfPath.from_string("trunk/mid2")),
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref.sub_ref(ConfPath.from_string("trunk/mid2")),
+        values=ValueReference(ConfPath.from_string("trunk/mid2"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "leaf21": "31",
+        "leaf22": "32",
+    }
+
+
+def test_override_action():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": OverrideAction(OverrideActionEnum.Clear, None),
+                "leaf12": OverrideAction(OverrideActionEnum.Append, "34"),
+            },
+            "mid2": {
+                "leaf21": OverrideAction(OverrideActionEnum.Remove, "2"),
+                "leaf22": OverrideAction(OverrideActionEnum.Assign, "99"),
+            },
+        },
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    pprint(override_values)
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "trunk": {
+            "mid1": {
+                "leaf12": "1234",
+            },
+            "mid2": {
+                "leaf21": "1",
+                "leaf22": "99",
+            },
+        },
+    }
+
+
+def test_override_override_action_append_prepend_remove():
+    trunk = ConfigOption("trunk")
+    trunk.insert_multiple(
+        [
+            StringConfigOption("str"),
+            ListOfStrConfigOption("list"),
+            DictOfStrConfigOption("dict"),
+        ]
+    )
+    opts = ConfigOption("root")
+    opts.insert(trunk)
+    values = {
+        "trunk": {
+            "str": "abcdef",
+            "list": ["abc", "def"],
+            "dict": {"x": "abcdef"},
+        },
+    }
+    override_values = [
+        {
+            "trunk": {
+                "str": OverrideAction(OverrideActionEnum.Append, "ghi"),
+                "list": OverrideAction(OverrideActionEnum.Append, ["ghi"]),
+                "dict": {"x": OverrideAction(OverrideActionEnum.Append, "ghi")},
+            }
+        },
+        {
+            "trunk": {
+                "str": OverrideAction(OverrideActionEnum.Prepend, "xyz"),
+                "list": OverrideAction(OverrideActionEnum.Prepend, ["xyz"]),
+                "dict": {"x": OverrideAction(OverrideActionEnum.Prepend, "xyz")},
+            }
+        },
+        {
+            "trunk": {
+                "str": OverrideAction(OverrideActionEnum.Remove, "def"),
+                "list": OverrideAction(OverrideActionEnum.Remove, ["def"]),
+                "dict": {"x": OverrideAction(OverrideActionEnum.Remove, "def")},
+            }
+        },
+    ]
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    for ovr in override_values:
+        verified = ConfigVerifier(
+            root=root_ref,
+            ref=root_ref,
+            values=ValueReference(ConfPath.from_string("/override"), ovr),
+        ).verify()
+        rval.values = ConfigOverrider(
+            root=root_ref,
+            ref=root_ref,
+            values=rval,
+            new_values=ValueReference(ConfPath.from_string("/override"), verified),
+        ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).finalize()
+
+    assert finalized_values == {
+        "trunk": {
+            "str": "xyzabcghi",
+            "list": ["xyz", "abc", "ghi"],
+            "dict": {"x": "xyzabcghi"},
+        },
+    }
+
+
+def test_override_trunk():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {
+        "mid1": {
+            "leaf12": "33",
+        },
+        "mid2": {
+            "leaf21": "31",
+            "leaf22": "32",
+        },
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref.sub_ref("trunk"),
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref.sub_ref("trunk"),
+        values=rval.sub_ref("trunk"),
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref.sub_ref("trunk"),
+        values=ValueReference(ConfPath.from_string("/override"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "mid1": {
+            "leaf11": "11",
+            "leaf12": "33",
+        },
+        "mid2": {
+            "leaf21": "31",
+            "leaf22": "32",
+        },
+    }
+
+
+def test_override_root():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {
+        "trunk": {
+            "mid1": {
+                "leaf12": "33",
+            },
+            "mid2": {
+                "leaf21": "31",
+                "leaf22": "32",
+            },
+        }
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "33",
+            },
+            "mid2": {
+                "leaf21": "31",
+                "leaf22": "32",
+            },
+        }
+    }
+
+
+def test_override_root_verify():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {
+        "trunk": {
+            "mid1": {
+                "leaf12": "33",
+            },
+            "mid2": {
+                "leaf21": "31",
+                "leaf22": "32",
+            },
+        }
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "33",
+            },
+            "mid2": {
+                "leaf21": "31",
+                "leaf22": "32",
+            },
+        }
+    }
+
+
+def test_override_root_verify_unknown_option():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {
+        "trunk": {
+            "mid1": {
+                "leaf12": "33",
+            },
+            "mid2": {
+                "leaf21": "31",
+                "leaf22": "32",
+                "leaf23": "32",
+            },
+        }
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    with pytest.raises(
+        ConfigError,
+        match="^Unknown option 'leaf23' in override/trunk/mid2. Did you mean: leaf22, leaf21$",
+    ):
+        ConfigVerifier(
+            root=root_ref,
+            ref=root_ref,
+            values=ValueReference(ConfPath.from_string("/override"), override_values),
+        ).verify()
+
+
+def test_override_root_verify_wrong_type():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "11",
+                "leaf12": "12",
+            },
+            "mid2": {
+                "leaf21": "21",
+                "leaf22": "22",
+            },
+        },
+    }
+    override_values = {
+        "trunk": {
+            "mid1": {
+                "leaf12": "33",
+            },
+            "mid2": {
+                "leaf21": "31",
+                "leaf22": 32,
+            },
+        }
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    with pytest.raises(
+        ConfigError,
+        match="^Type of override/trunk/mid2/leaf22 should be <class 'str'>, not <class 'int'>$",
+    ):
+        ConfigVerifier(
+            root=root_ref,
+            ref=root_ref,
+            values=ValueReference(ConfPath.from_string("/override"), override_values),
+        ).verify()
+
+
+def test_override_append_prepend_assign():
+    opts = ConfigOption("root")
+    trunk = ConfigOption("trunk")
+    subopt = ConfigOption("subopt")
+    subopt.insert_multiple(
+        [
+            ListOfStrConfigOption("args0a", append_by_default=True),
+            ListOfStrConfigOption("args1a"),
+            ListOfStrConfigOption("args1b"),
+            ListOfStrConfigOption("args1c"),
+            ListOfStrConfigOption("args2a"),
+            ListOfStrConfigOption("args2b"),
+            ListOfStrConfigOption("args3a"),
+            ListOfStrConfigOption("args3b"),
+            ListOfStrConfigOption("args3c"),
+        ]
+    )
+    trunk.insert(subopt)
+    opts.insert(trunk)
+
+    values = {
+        "trunk": {
+            "subopt": {
+                "args0a": ["abc", "def", "ghi"],
+                "args1a": ["abc", "def", "ghi"],
+                "args1b": ["abc", "def", "ghi"],
+                "args1c": ["abc", "def", "ghi"],
+                "args2a": [],
+                "args2b": [],
+            },
+        },
+    }
+    override_values = {
+        "subopt": {
+            "args0a": ["123"],
+            "args1a": ["123"],
+            "args1b": {"=": ["456"]},
+            "args1c": {"-": ["def", "xyz"], "+": ["jkl"], "prepend": ["000"]},
+            "args2a": {"+": ["789"]},
+            "args2b": {"=": ["321"]},
+            "args3a": {"+": ["654"]},
+            "args3b": {"=": ["987"]},
+            "args3c": {"-": ["foo"]},
+        },
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref.sub_ref("trunk"),
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref.sub_ref("trunk"),
+        values=rval.sub_ref("trunk"),
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref.sub_ref("trunk"),
+        values=ValueReference(ConfPath.from_string("/override"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "subopt": {
+            "args0a": ["abc", "def", "ghi", "123"],
+            "args1a": ["123"],
+            "args1b": ["456"],
+            "args1c": ["000", "abc", "ghi", "jkl"],
+            "args2a": ["789"],
+            "args2b": ["321"],
+            "args3a": ["654"],
+            "args3b": ["987"],
+            "args3c": [],
+        },
+    }
+
+
+class ConfigTestOption(ConfigOption):
+    def override(self, old_value, new_value):
+        if old_value.values is None:
+            return new_value.values
+        assert isinstance(old_value.values, str)
+        assert isinstance(new_value.values, str)
+        return old_value.values + "+" + new_value.values
+
+    def verify(self, values: ValueReference) -> Any:
+        assert isinstance(values.values, str)
+        return values.values
+
+
+def test_override_no_inherit():
+    root = ConfigOption("")
+    a = root.sub_options["a"] = ConfigOption("a")
+    a.sub_options["1"] = ConfigTestOption("1")
+    a.sub_options["2"] = ConfigTestOption("2")
+    a.sub_options["3"] = ConfigTestOption("3")
+    b = root.sub_options["b"] = ConfigOption("b")
+    b.sub_options["1"] = ConfigTestOption("1")
+
+    values = {"a": {"1": "a1", "2": "a2"}}
+    override_values = {"a": {"2": "A2", "3": "A3"}, "b": {"1": "B1"}}
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), root)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), overridden_values),
+    ).finalize()
+
+    pprint(finalized_values)
+    assert finalized_values == {
+        "a": {"1": "a1", "2": "a2+A2", "3": "A3"},
+        "b": {"1": "B1"},
+    }
+
+
+def test_override_inherit():
+    root = ConfigOption("")
+    a = root.sub_options["a"] = ConfigOption("a")
+    a.sub_options["1"] = ConfigTestOption("1")
+    a.sub_options["2"] = ConfigTestOption("2")
+    a.sub_options["3"] = ConfigTestOption("3")
+    b = root.sub_options["b"] = ConfigOption("b")
+    b.sub_options["1"] = ConfigTestOption("1")
+    c = root.sub_options["c"] = ConfigOption("c")
+    c.inherits = ConfPath.from_string("/a")
+    d = root.sub_options["d"] = ConfigOption("d")
+    d.inherits = ConfPath.from_string("/a/1")
+    e = root.sub_options["e"] = ConfigOption("e")
+    e.inherits = ConfPath.from_string("/c")
+
+    values = {"a": {"1": "a1", "2": "a2"}}
+    override_values = {
+        "a": {"2": "A2", "3": "A3"},
+        "b": {"1": "B1"},
+        "c": {"1": "C1"},
+        "d": "D",
+        "e": {"3": "E3"},
+    }
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), root)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+        new_values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), overridden_values),
+    ).finalize()
+
+    pprint(finalized_values)
+    assert finalized_values == {
+        "a": {"1": "a1", "2": "a2+A2", "3": "A3"},
+        "b": {"1": "B1"},
+        "c": {"1": "C1"},
+        "d": "D",
+        "e": {"3": "E3"},
+    }
+
+
+def test_override_action_inherit():
+    a = ConfigOption("a")
+    a.insert_multiple(
+        [
+            StringConfigOption("str_append_clear"),
+            StringConfigOption("str_clear_append"),
+            StringConfigOption("str_append_remove_1"),
+            StringConfigOption("str_append_remove_2"),
+            StringConfigOption("str_remove_append_1"),
+            StringConfigOption("str_remove_append_2"),
+        ]
+    )
+    b = ConfigOption("b")
+    b.inherits = ConfPath.from_string("/a")
+    opts = ConfigOption("")
+    opts.insert_multiple([a, b])
+
+    values = {
+        "a": {
+            "str_append_clear": "abcdef",
+            "str_clear_append": "abcdef",
+            "str_append_remove_1": "abcdef",
+            "str_append_remove_2": "abcdef",
+            "str_remove_append_1": "abcdef",
+            "str_remove_append_2": "abcdef",
+        },
+        "b": {
+            "str_append_clear": OverrideAction(OverrideActionEnum.Append, "ghi"),
+            "str_clear_append": OverrideAction(OverrideActionEnum.Clear, None),
+            "str_append_remove_1": OverrideAction(OverrideActionEnum.Append, "ghi"),
+            "str_append_remove_2": OverrideAction(OverrideActionEnum.Append, "ghi"),
+            "str_remove_append_1": OverrideAction(OverrideActionEnum.Remove, "de"),
+            "str_remove_append_2": OverrideAction(OverrideActionEnum.Remove, "gh"),
+        },
+    }
+    override_values = [
+        {
+            "b": {
+                "str_append_clear": OverrideAction(OverrideActionEnum.Clear, None),
+                "str_clear_append": OverrideAction(OverrideActionEnum.Append, "ghi"),
+                "str_append_remove_1": OverrideAction(OverrideActionEnum.Remove, "de"),
+                "str_append_remove_2": OverrideAction(OverrideActionEnum.Remove, "gh"),
+                "str_remove_append_1": OverrideAction(OverrideActionEnum.Append, "ghi"),
+                "str_remove_append_2": OverrideAction(OverrideActionEnum.Append, "ghi"),
+            }
+        }
+    ]
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    for ovr in override_values:
+        verified = ConfigVerifier(
+            root=root_ref,
+            ref=root_ref,
+            values=ValueReference(ConfPath.from_string("/override"), ovr),
+        ).verify()
+        rval.values = ConfigOverrider(
+            root=root_ref,
+            ref=root_ref,
+            values=rval,
+            new_values=ValueReference(ConfPath.from_string("/override"), verified),
+        ).override()
+    ConfigInheritor(
+        root=root_ref,
+        root_values=rval,
+    ).inherit()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).finalize()
+
+    pprint(finalized_values)
+    assert finalized_values == {
+        "a": {
+            "str_append_clear": "abcdef",
+            "str_clear_append": "abcdef",
+            "str_append_remove_1": "abcdef",
+            "str_append_remove_2": "abcdef",
+            "str_remove_append_1": "abcdef",
+            "str_remove_append_2": "abcdef",
+        },
+        "b": {
+            # "str_append_clear": <unset>,
+            "str_clear_append": "ghi",
+            "str_append_remove_1": "abcfghi",
+            "str_append_remove_2": "abcdefi",
+            "str_remove_append_1": "abcfghi",
+            "str_remove_append_2": "abcdefghi",
+        },
+    }
+
+
+def test_inherit():
+    root = ConfigOption("")
+    a = root.sub_options["a"] = ConfigOption("a")
+    a.sub_options["1"] = ConfigTestOption("1")
+    a.sub_options["2"] = ConfigTestOption("2")
+    a.sub_options["3"] = ConfigTestOption("3")
+    b = root.sub_options["b"] = ConfigOption("b")
+    b.sub_options["1"] = ConfigTestOption("1")
+    c = root.sub_options["c"] = ConfigOption("c")
+    c.inherits = ConfPath.from_string("/a")
+    c.create_if_inheritance_target_exists = True
+    d = root.sub_options["d"] = ConfigOption("d")
+    d.inherits = ConfPath.from_string("/a/1")
+    d.create_if_inheritance_target_exists = True
+    e = root.sub_options["e"] = ConfigOption("e")
+    e.inherits = ConfPath.from_string("/c")
+    e.create_if_inheritance_target_exists = True
+
+    values = {
+        "a": {"1": "a1", "2": "a2"},
+        "b": {"1": "B1"},
+        "c": {"1": "C1"},
+        "d": "D1",
+        "e": {"1": "E1", "2": "E2", "3": "E3"},
+    }
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), root)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    ConfigInheritor(
+        root=root_ref,
+        root_values=rval,
+    ).inherit()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).finalize()
+
+    print(finalized_values)
+    assert finalized_values == {
+        "a": {"1": "a1", "2": "a2"},
+        "b": {"1": "B1"},
+        "c": {"1": "a1+C1", "2": "a2"},
+        "d": "a1+D1",
+        "e": {"1": "a1+C1+E1", "2": "a2+E2", "3": "E3"},
+    }
+
+
+class VerifiedConfigOption(ConfigOption):
+    def __init__(self, name, verified: set) -> None:
+        super().__init__(name)
+        self.verified = verified
+
+    def verify(self, values: ValueReference):
+        self.verified.add(values.value_path.pth)
+        return values.values
+
+
+def test_verify():
+    verified = set()
+    root = ConfigOption("")
+    a = root.sub_options["a"] = ConfigOption("a")
+    a.sub_options["1"] = VerifiedConfigOption("1", verified)
+    a.sub_options["2"] = VerifiedConfigOption("2", verified)
+    a.sub_options["3"] = VerifiedConfigOption("3", verified)
+    b = root.sub_options["b"] = ConfigOption("b")
+    b.sub_options["1"] = VerifiedConfigOption("1", verified)
+    c = root.sub_options["c"] = ConfigOption("c")
+    c.inherits = ConfPath.from_string("/a")
+    c.create_if_inheritance_target_exists = True
+    d = root.sub_options["d"] = ConfigOption("d")
+    d.inherits = ConfPath.from_string("/a/1")
+    d.create_if_inheritance_target_exists = True
+    e = root.sub_options["e"] = ConfigOption("e")
+    e.inherits = ConfPath.from_string("/c")
+    e.create_if_inheritance_target_exists = True
+
+    values = {
+        "a": {"1": "a1", "2": "a2"},
+        "b": {"1": "B1"},
+        "c": {"1": "C1"},
+        "d": "D1",
+        "e": {"1": "E1", "2": "E2", "3": "E3"},
+    }
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), root)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    verified_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/"), verified_values),
+    ).finalize()
+
+    print(finalized_values)
+    assert finalized_values == values
+    assert verified == {
+        ConfPath.from_string("a/1").pth,
+        ConfPath.from_string("a/2").pth,
+        ConfPath.from_string("b/1").pth,
+        ConfPath.from_string("c/1").pth,
+        ConfPath.from_string("d").pth,
+        ConfPath.from_string("e/1").pth,
+        ConfPath.from_string("e/2").pth,
+        ConfPath.from_string("e/3").pth,
+    }
+
+
+def test_default():
+    root = ConfigOption("")
+    root.insert_multiple(
+        [
+            # Default value
+            ConfigTestOption("a", default=DefaultValueValue("foo")),
+            # Refer to other (existing) value
+            ConfigTestOption(
+                "b", default=RefDefaultValue(ConfPath.from_string("a"), relative=True)
+            ),
+            ConfigTestOption(
+                "c", default=RefDefaultValue(ConfPath.from_string("a"), relative=False)
+            ),
+            ConfigTestOption(
+                "d", default=RefDefaultValue(ConfPath.from_string("b"), relative=False)
+            ),
+            ConfigTestOption(
+                "e", default=RefDefaultValue(ConfPath.from_string("c"), relative=False)
+            ),
+            # Refer to other (existing) value, but it already has a value
+            ConfigTestOption(
+                "f", default=RefDefaultValue(ConfPath.from_string("a"), relative=True)
+            ),
+            ConfigTestOption(
+                "g", default=RefDefaultValue(ConfPath.from_string("f"), relative=True)
+            ),
+            ConfigTestOption(
+                "h", default=RefDefaultValue(ConfPath.from_string("g"), relative=True)
+            ),
+            # No default value (should not create any values)
+            ConfigTestOption("i"),
+            ConfigTestOption("j", default=NoDefaultValue()),
+            ConfigTestOption("k", default=NoDefaultValue()),
+            # Refer to another (unset) value
+            ConfigTestOption("l", default=RefDefaultValue(ConfPath.from_string("k"))),
+            ConfigTestOption("r", default=RequiredValue()),
+            ConfigOption("s", default=DefaultValueValue({})).insert_multiple(
+                [
+                    ConfigTestOption("1", default=DefaultValueValue("s1d")),
+                    ConfigTestOption(
+                        "2", default=RefDefaultValue(ConfPath.from_string("g"))
+                    ),
+                    ConfigTestOption("3", default=NoDefaultValue()),
+                    ConfigTestOption(
+                        "4",
+                        default=RefDefaultValue(
+                            ConfPath.from_string("2"), relative=True
+                        ),
+                    ),
+                ]
+            ),
+        ]
+    )
+    values = {"f": "bar", "j": "zzz", "r": "baz"}
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), root)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    rval.values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).finalize()
+    ConfigDefaulter(
+        root=root_ref,
+        root_values=rval,
+    ).update_default()
+
+    print(rval.values)
+    assert rval.values == {
+        "a": "foo",
+        "b": "foo",
+        "c": "foo",
+        "d": "foo",
+        "e": "foo",
+        "f": "bar",
+        "g": "bar",
+        "h": "bar",
+        "j": "zzz",
+        "r": "baz",
+        "s": {
+            "1": "s1d",
+            "2": "bar",
+            "4": "bar",
+        },
+    }
+
+
+def test_default_missing():
+    root = ConfigOption("")
+    root.insert_multiple(
+        [
+            ConfigTestOption("a", default=RequiredValue()),
+            ConfigTestOption("mis", default=RequiredValue()),
+        ]
+    )
+    values = {"a": "foo"}
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), root)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    rval.values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).finalize()
+    defaulter = ConfigDefaulter(
+        root=root_ref,
+        root_values=rval,
+    )
+    with pytest.raises(MissingDefaultError, match="^mis requires a value$"):
+        defaulter.update_default()
diff --git a/tests/test_configoptions_cmake.py b/tests/test_configoptions_cmake.py
new file mode 100644
index 0000000..5bd9ed7
--- /dev/null
+++ b/tests/test_configoptions_cmake.py
@@ -0,0 +1,292 @@
+from pprint import pprint
+
+import pytest
+from py_build_cmake.common import ConfigError
+from py_build_cmake.config.load import (
+    inherit_default_and_finalize_config,
+    verify_and_override_config,
+)
+from py_build_cmake.config.options.cmake_opt import CMakeOptConfigOption
+from py_build_cmake.config.options.config_option import ConfigOption, MultiConfigOption
+from py_build_cmake.config.options.config_path import ConfPath
+from py_build_cmake.config.options.config_reference import ConfigReference
+from py_build_cmake.config.options.value_reference import ValueReference
+
+
+def test_cmake_options_str_list_dict():
+    opts = ConfigOption("root")
+    trunk = ConfigOption("pyproject.toml")
+    cmake = ConfigOption("cmake")
+    cmake.insert_multiple(
+        [
+            CMakeOptConfigOption("opt1"),
+            CMakeOptConfigOption("opt2"),
+            CMakeOptConfigOption("opt3"),
+            CMakeOptConfigOption("opt4"),
+            CMakeOptConfigOption("opt5"),
+        ]
+    )
+    trunk.insert(cmake)
+    opts.insert(trunk)
+
+    values = {
+        "pyproject.toml": {
+            "cmake": {
+                "opt1": {"FOO1": "bar"},
+                "opt2": {"FOO2": ["a", "b"]},
+                "opt3": {"FOO3": {"value": "c", "type": "BOOL", "strict": False}},
+                "opt4": {"FOO4": {"value": "d"}},
+                "opt5": {"FOO5": {"value": ["e", "f"], "type": "STRING"}},
+            },
+        },
+    }
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    verify_and_override_config({}, root_ref, root_val)
+    inherit_default_and_finalize_config(root_ref, root_val)
+
+    pprint(root_val.values)
+    assert root_val.values == {
+        "pyproject.toml": {
+            "cmake": {
+                "opt1": {"FOO1": "bar"},
+                "opt2": {"FOO2": "a;b"},
+                "opt3": {"FOO3:BOOL": "c"},
+                "opt4": {"FOO4": "d"},
+                "opt5": {"FOO5:STRING": "e;f"},
+            }
+        }
+    }
+
+
+def test_cmake_options_wrong_type():
+    opts = ConfigOption("root")
+    trunk = ConfigOption("pyproject.toml")
+    cmake = ConfigOption("cmake")
+    cmake.insert(CMakeOptConfigOption("opt1"))
+    trunk.insert(cmake)
+    opts.insert(trunk)
+
+    values = {"pyproject.toml": {"cmake": {"opt1": {"FOO1": 42}}}}
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    expected = r"Type of values in pyproject\.toml/cmake/opt1/FOO1 should be str or bool or a list thereof, not .*int.*"
+    with pytest.raises(ConfigError, match=f"^{expected}$"):
+        verify_and_override_config({}, root_ref, root_val)
+
+    values = {"pyproject.toml": {"cmake": {"opt1": {"FOO1": [42]}}}}
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    expected = r"Type of values in list pyproject\.toml/cmake/opt1/FOO1 should be str or bool, not .*int.*"
+    with pytest.raises(ConfigError, match=f"^{expected}$"):
+        verify_and_override_config({}, root_ref, root_val)
+
+    values = {"pyproject.toml": {"cmake": {"opt1": {"FOO1": {"value": [42]}}}}}
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    expected = r"Type of values in list pyproject\.toml/cmake/opt1/FOO1/value should be str or bool, not .*int.*"
+    with pytest.raises(ConfigError, match=f"^{expected}$"):
+        verify_and_override_config({}, root_ref, root_val)
+
+
+def test_cmake_options_invalid_key():
+    opts = ConfigOption("root")
+    trunk = ConfigOption("pyproject.toml")
+    cmake = ConfigOption("cmake")
+    cmake.insert(CMakeOptConfigOption("opt1"))
+    trunk.insert(cmake)
+    opts.insert(trunk)
+
+    values = {"pyproject.toml": {"cmake": {"opt1": {"FOO1": {"valuezzz": "a"}}}}}
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    expected = r"Invalid keys in pyproject\.toml/cmake/opt1/FOO1: \['valuezzz'\]"
+    with pytest.raises(ConfigError, match=f"^{expected}$"):
+        verify_and_override_config({}, root_ref, root_val)
+
+    values = {"pyproject.toml": {"cmake": {"opt1": {"FOO1": {"value": "a", "+": "b"}}}}}
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    expected = r"Invalid keys in pyproject.toml/cmake/opt1/FOO1: "
+    expected += r'Cannot combine "value" or "=" with the following keys: \[\'\+\'\]'
+    with pytest.raises(ConfigError, match=f"^{expected}$"):
+        verify_and_override_config({}, root_ref, root_val)
+
+
+def test_cmake_options_invalid_typename():
+    opts = ConfigOption("root")
+    trunk = ConfigOption("pyproject.toml")
+    cmake = ConfigOption("cmake")
+    cmake.insert(CMakeOptConfigOption("opt1"))
+    trunk.insert(cmake)
+    opts.insert(trunk)
+
+    values = {
+        "pyproject.toml": {
+            "cmake": {"opt1": {"FOO1": {"value": "a", "type": "STRINGZ"}}}
+        }
+    }
+
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    expected = r"Unknown type 'STRINGZ' in pyproject\.toml/cmake/opt1/FOO1"
+    with pytest.raises(ConfigError, match=f"^{expected}$"):
+        verify_and_override_config({}, root_ref, root_val)
+
+
+def test_cmake_options_override():
+    opts = ConfigOption("root")
+    trunk = ConfigOption("pyproject.toml")
+    cmake = MultiConfigOption("cmake")
+    cmake.insert_multiple(
+        [
+            CMakeOptConfigOption("opt1"),
+            CMakeOptConfigOption("opt2"),
+            CMakeOptConfigOption("opt3"),
+            CMakeOptConfigOption("opt4"),
+            CMakeOptConfigOption("opt5"),
+        ]
+    )
+    trunk.insert(cmake)
+    opts.insert(trunk)
+
+    values = {
+        "pyproject.toml": {
+            "cmake": {
+                "opt1": {"FOO1": "bar"},
+                "opt2": {"FOO2": ["a", "b"]},
+                "opt3": {"FOO3": {"value": "c", "type": "BOOL", "strict": False}},
+                "opt4": {"FOO4": {"value": "d"}},
+                "opt5": {"FOO5": {"value": ["e", "f"], "type": "STRING"}},
+            },
+        },
+        "override": {
+            # Simply combine unrelated options
+            "opt1": {"BAR1": "foo"},
+            # Override option
+            "opt2": {"FOO2": "o"},
+            # Append option
+            "opt3": {"FOO3": {"append": "x"}},
+            # Prepend option
+            "opt4": {"FOO4": {"prepend": "y"}},
+            # Remove option
+            "opt5": {"FOO5": {"-": "f", "+": "g", "type": "STRING"}},
+        },
+    }
+
+    override = {
+        ConfPath.from_string("override"): ConfPath.from_string("pyproject.toml/cmake")
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    verify_and_override_config(override, root_ref, root_val)
+    inherit_default_and_finalize_config(root_ref, root_val)
+
+    root_val.values.pop("override")
+    pprint(root_val.values)
+    assert root_val.values == {
+        "pyproject.toml": {
+            "cmake": {
+                "0": {
+                    "opt1": {"FOO1": "bar", "BAR1": "foo"},
+                    "opt2": {"FOO2": "o"},
+                    "opt3": {"FOO3:BOOL": "c;x"},
+                    "opt4": {"FOO4": "y;d"},
+                    "opt5": {"FOO5:STRING": "e;g"},
+                }
+            }
+        }
+    }
+
+
+def test_cmake_options_override_wrong_type():
+    opts = ConfigOption("root")
+    trunk = ConfigOption("pyproject.toml")
+    cmake = MultiConfigOption("cmake")
+    cmake.insert_multiple(
+        [
+            CMakeOptConfigOption("opt1"),
+        ]
+    )
+    trunk.insert(cmake)
+    opts.insert(trunk)
+
+    values = {
+        "pyproject.toml": {
+            "cmake": {
+                "opt1": {"FOO1": {"value": "Off", "type": "BOOL"}},
+            },
+        },
+        "override": {
+            # This one has type STRING instead of BOOL
+            "opt1": {"FOO1": {"prepend": "foo", "type": "STRING"}},
+        },
+    }
+
+    override = {
+        ConfPath.from_string("override"): ConfPath.from_string("pyproject.toml/cmake")
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    expected = (
+        r"Incompatible types when overriding or inheriting CMake settings: "
+        r"BOOL \(pyproject.toml/cmake/\*/opt1/FOO1\) and "
+        r"STRING \(override/\*/opt1/FOO1\) \(use \"strict\" = false to ignore\)"
+    )
+    with pytest.raises(ConfigError, match=expected):
+        verify_and_override_config(override, root_ref, root_val)
+
+
+def test_cmake_options_override_wrong_type_lax():
+    opts = ConfigOption("root")
+    trunk = ConfigOption("pyproject.toml")
+    cmake = MultiConfigOption("cmake")
+    cmake.insert_multiple(
+        [
+            CMakeOptConfigOption("opt1"),
+        ]
+    )
+    trunk.insert(cmake)
+    opts.insert(trunk)
+
+    values = {
+        "pyproject.toml": {
+            "cmake": {
+                "opt1": {"FOO1": {"value": True, "type": "BOOL"}},
+            },
+        },
+        "override": {
+            # This one has type STRING instead of BOOL
+            "opt1": {"FOO1": {"prepend": "foo", "type": "STRING", "strict": False}},
+        },
+    }
+
+    override = {
+        ConfPath.from_string("override"): ConfPath.from_string("pyproject.toml/cmake")
+    }
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    root_val = ValueReference(ConfPath.from_string("/"), values)
+    verify_and_override_config(override, root_ref, root_val)
+    inherit_default_and_finalize_config(root_ref, root_val)
+
+    root_val.values.pop("override")
+    pprint(root_val.values)
+    assert root_val.values == {
+        "pyproject.toml": {
+            "cmake": {
+                "0": {
+                    "opt1": {"FOO1:STRING": "foo;On"},
+                }
+            }
+        }
+    }
+
+
+if __name__ == "__main__":
+    test_cmake_options_override()
diff --git a/tests/test_configoptions_multi.py b/tests/test_configoptions_multi.py
new file mode 100644
index 0000000..d26fe72
--- /dev/null
+++ b/tests/test_configoptions_multi.py
@@ -0,0 +1,161 @@
+from pprint import pprint
+
+from py_build_cmake.config.options.config_option import ConfigOption, MultiConfigOption
+from py_build_cmake.config.options.config_path import ConfPath
+from py_build_cmake.config.options.config_reference import ConfigReference
+from py_build_cmake.config.options.finalize import ConfigFinalizer
+from py_build_cmake.config.options.override import ConfigOverrider
+from py_build_cmake.config.options.string import StringConfigOption
+from py_build_cmake.config.options.value_reference import (
+    ValueReference,
+)
+from py_build_cmake.config.options.verify import ConfigVerifier
+
+
+def gen_test_opts():
+    leaf11 = StringConfigOption("leaf11")
+    leaf12 = StringConfigOption("leaf12")
+    mid1 = MultiConfigOption("mid1")
+    mid1.insert(leaf11)
+    mid1.insert(leaf12)
+    trunk = ConfigOption("trunk")
+    trunk.insert(mid1)
+    opts = ConfigOption("root")
+    opts.insert(trunk)
+    return opts
+
+
+def test_override0():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "*1",
+                "leaf12": "*2",
+                "0": {"leaf11": "11", "leaf12": "12"},
+                "10": {"leaf11": "111"},
+                "20": {},
+            },
+        },
+    }
+    override_values = {}  # No override
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    pprint(rval.values)
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+        new_values=ValueReference(ConfPath.from_string("/"), override_values),
+    ).override()
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "trunk": {
+            "mid1": {
+                "0": {
+                    "leaf11": "11",
+                    "leaf12": "12",
+                },
+                "10": {
+                    "leaf11": "111",
+                    "leaf12": "*2",
+                },
+                "20": {
+                    "leaf11": "*1",
+                    "leaf12": "*2",
+                },
+            },
+        },
+    }
+
+
+def test_override1():
+    opts = gen_test_opts()
+    values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "*1",
+                "leaf12": "*2",
+                "0": {"leaf11": "11", "leaf12": "12"},
+                "10": {
+                    "leaf11": "111",
+                },
+            },
+        },
+    }
+    override_values = {
+        "trunk": {
+            "mid1": {
+                "leaf11": "-1*",
+                "10": {"leaf12": "-12"},
+                "20": {"leaf11": "1111"},
+                "30": {},
+            },
+        },
+    }  # No override
+    root_ref = ConfigReference(ConfPath.from_string("/"), opts)
+    rval = ValueReference(ConfPath.from_string("/"), values)
+
+    rval.values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+    ).verify()
+    pprint(rval.values)
+    override_values = ConfigVerifier(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/override"), override_values),
+    ).verify()
+    pprint(override_values)
+    overridden_values = ConfigOverrider(
+        root=root_ref,
+        ref=root_ref,
+        values=rval,
+        new_values=ValueReference(ConfPath.from_string("/"), override_values),
+    ).override()
+    pprint(overridden_values)
+    finalized_values = ConfigFinalizer(
+        root=root_ref,
+        ref=root_ref,
+        values=ValueReference(ConfPath.from_string("/"), overridden_values),
+    ).finalize()
+
+    assert finalized_values == {
+        "trunk": {
+            "mid1": {
+                "0": {
+                    "leaf11": "11",
+                    "leaf12": "12",
+                },
+                "10": {
+                    "leaf11": "111",
+                    "leaf12": "-12",
+                },
+                "20": {
+                    "leaf11": "1111",
+                    "leaf12": "*2",
+                },
+                "30": {
+                    "leaf11": "-1*",
+                    "leaf12": "*2",
+                },
+            },
+        },
+    }
diff --git a/tests/test_macos_platform_tag.py b/tests/test_macos_platform_tag.py
new file mode 100644
index 0000000..317d0ca
--- /dev/null
+++ b/tests/test_macos_platform_tag.py
@@ -0,0 +1,17 @@
+from py_build_cmake.export.native_tags import _guess_platform_tag_mac as guess_tag
+
+
+def test_parse_cli():
+    test = lambda a, b: guess_tag({"ARCHFLAGS": a, "MACOSX_DEPLOYMENT_TARGET": b})
+    assert test("-arch arm64", "10.15") == "macosx_11_0_arm64"
+    assert test("-arch arm64", "11.7") == "macosx_11_7_arm64"
+    assert test("-arch arm64", "12.3") == "macosx_12_3_arm64"
+    assert test("-arch x86_64", "10.15") == "macosx_10_15_x86_64"
+    assert test("-arch x86_64", "11.7") == "macosx_11_7_x86_64"
+    assert test("-arch x86_64", "12.3") == "macosx_12_3_x86_64"
+    assert test("-arch x86_64 -arch arm64", "10.15") == "macosx_10_15_universal2"
+    assert test("-arch x86_64 -arch arm64", "11.7") == "macosx_11_7_universal2"
+    assert test("-arch x86_64 -arch arm64", "12.3") == "macosx_12_3_universal2"
+    assert test("-arch arm64 -arch x86_64", "10.15") == "macosx_10_15_universal2"
+    assert test("-arch arm64 -arch x86_64", "11.7") == "macosx_11_7_universal2"
+    assert test("-arch arm64 -arch x86_64", "12.3") == "macosx_12_3_universal2"