Update documentation

README.md

@@ -10,6 +10,9 @@
 ![test-eve](https://github.com/GridTools/gt4py/actions/workflows/test-eve.yml/badge.svg?branch=main)
 ![qa](https://github.com/GridTools/gt4py/actions/workflows/code-quality.yml/badge.svg?branch=main)
 
+[![uv](https://img.shields.io/badge/-uv-261230.svg?logo=uv)](https://github.com/astral-sh/uv)
+[![Nox](https://img.shields.io/badge/%F0%9F%A6%8A-Nox-D85E00.svg)](https://github.com/wntrblm/nox)
+
 # GT4Py: GridTools for Python
 
 GT4Py is a Python library for generating high performance implementations of stencil kernels from a high-level definition using regular Python functions. GT4Py is part of the GridTools framework, a set of libraries and utilities to develop performance portable applications in the area of weather and climate modeling.
@@ -36,18 +39,18 @@ The following backends are supported:
 
 ## 🚜 Installation
 
-GT4Py can be installed as a regular Python package using `pip` (or any other PEP-517 frontend). As usual, we strongly recommended to create a new virtual environment to work on this project.
+GT4Py can be installed as a regular Python package using [uv](https://docs.astral.sh/uv/), [pip](https://pip.pypa.io/en/stable/) or any other PEP-517 compatible frontend. We strongly recommended to use`uv` to create and manage virtual environments for your own projects.
 
 The performance backends also require the [Boost](https://www.boost.org) library, a dependency of [GridTools C++](https://github.com/GridTools/gridtools), which needs to be installed by the user.
 
 ## ⚙ Configuration
 
-If GridTools or Boost are not found in the compiler's standard include path, or a custom version is desired, then a couple configuration environment variables will allow the compiler to use them:
+To explicitly set the [GridTools-C++](https://gridtools.github.io/gridtools) or [Boost](https://www.boost.org) versions used by the code generation backends, the following environment variables can be used:
 
 - `GT_INCLUDE_PATH`: Path to the GridTools installation.
 - `BOOST_ROOT`: Path to a boost installation.
 
-Other commonly used environment variables are:
+Other useful available environment variables are:
 
 - `CUDA_ARCH`: Set the compute capability of the NVIDIA GPU if it is not detected automatically by `cupy`.
 - `CXX`: Set the C++ compiler.
@@ -56,67 +59,68 @@ Other commonly used environment variables are:
 
 More options and details are available in [`config.py`](https://github.com/GridTools/gt4py/blob/main/src/gt4py/cartesian/config.py).
 
-## 📖 Documentation
+## 🛠 Development Instructions
 
-GT4Py uses Sphinx documentation. To build the documentation install the dependencies in `requirements-dev.txt`
+Follow the installation instructions below to initialize a development virtual environment containing an _editable_ installation of the GT4Py package. Make sure you read the [CONTRIBUTING.md](CONTRIBUTING.md) and [CODING_GUIDELINES.md](CODING_GUIDELINES.md) documents before you start working on the project.
 
-```bash
-pip install -r ./gt4py/requirements-dev.txt
-```
+### Development Environment Installation using `uv`
 
-and then build the docs with
+GT4Py uses the [`uv`](https://docs.astral.sh/uv/) project manager for the development workflow. `uv` is a versatile tool that consolidates functionality usually distributed across different applications into subcommands.
 
-```bash
-cd gt4py/docs/user/cartesian
-make html  # run 'make help' for a list of targets
-```
+- The `uv pip` subcommand provides a _fast_ Python package manager, emulating [`pip`](https://pip.pypa.io/en/stable/).
+- The `uv export | lock | sync` subcommands manage dependency versions in a manner similar to the [`pip-tools`](https://pip-tools.readthedocs.io/en/stable/) command suite.
+- The `uv init | add | remove | build | publish | ...` subcommands facilitate project development workflows, akin to [`hatch`](https://hatch.pypa.io/latest/).
+- The `uv tool` subcommand serves as a runner for Python applications in isolation, similar to [`pipx`](https://pipx.pypa.io/stable/).
+- The `uv python` subcommands manage different Python installations and versions, much like [`pyenv`](https://github.com/pyenv/pyenv).
 
-## 🛠 Development Instructions
+`uv` can be installed in various ways (see its [installation instructions](https://docs.astral.sh/uv/getting-started/installation/)), with the recommended method being the standalone installer:
 
-Follow the installation instructions below to initialize a development virtual environment containing an _editable_ installation of the GT4Py package. Make sure you read the [CONTRIBUTING.md](CONTRIBUTING.md) and [CODING_GUIDELINES.md](CODING_GUIDELINES.md) documents before you start working on the project.
-
-### Recommended Installation using `tox`
+```bash
+$ curl -LsSf https://astral.sh/uv/install.sh | sh
+```
 
-If [tox](https://tox.wiki/en/latest/) is already installed in your system (`tox` is available in PyPI and many other package managers), the easiest way to create a virtual environment ready for development is:
+Once `uv` is installed in your system, it is enough to clone this repository and let `uv` handling the installation of the development environment.
 
 ```bash
 # Clone the repository
 git clone https://github.com/gridtools/gt4py.git
 cd gt4py
 
-# Create the development environment in any location (usually `.venv`)
-# selecting one of the following templates:
-#     dev-py310       -> base environment
-#     dev-py310-atlas -> base environment + atlas4py bindings
-tox devenv -e dev-py310 .venv
+# Let uv create the development environment at `.venv`.
+# The `--extra all` option tells uv to install all the optional
+# dependencies of gt4py, and thus it is not strictly necessary.
+# Note that if no dependency groups are provided as an option,
+# uv uses `--group dev` by default so the development dependencies
+# are installed.
+uv sync --extra all
 
-# Finally, activate the environment
+# Finally, activate the virtual environment and start writing code!
 source .venv/bin/activate
 ```
 
-### Manual Installation
+The newly created _venv_ is a standard Python virtual environment preconfigured with all necessary runtime and development dependencies. Additionally, the `gt4py` package is installed in editable mode, allowing for seamless development and testing. To install new packages in this environment, use the `uv pip` subcommand which emulates the `pip` interface and is generally much faster than the original `pip` tool (which is also available within the venv although its use is discouraged).
 
-Alternatively, a development environment can be created from scratch installing the frozen dependencies packages :
+The `pyproject.toml` file contains both the definition of the `gt4py` Python distribution package and the settings of the development tools used in this project, most notably `uv`, `ruff`, and `mypy`. It also contains _dependency groups_ (see [PEP 735](https://peps.python.org/pep-0735/) for further reference) with the development requirements listed in different groups (`build`, `docs`, `lint`, `test`, `typing`, ...) and collected together in the general `dev` group, which gets installed by default by `uv` as mentioned above.
 
-```bash
-# Clone the repository
-git clone https://github.com/gridtools/gt4py.git
-cd gt4py
+### Development Tasks (`dev-tasks.py`)
 
-# Create a (Python 3.10) virtual environment (usually at `.venv`)
-python3.10 -m venv .venv
+Recurrent development tasks like bumping versions of used development tools or required third party dependencies have been collected as different subcommands in the [`dev-tasks.py`](./dev-tasks.py) script. Read the tool help for a brief description of every task and always use this tool to update the versions and sync the version configuration accross different files (e.g. `pyproject.toml` and `.pre-commit-config.yaml`).
 
-# Activate the virtual environment and update basic packages
-source .venv/bin/activate
-pip install --upgrade wheel setuptools pip
+## 📖 Documentation
+
+GT4Py uses the Sphinx tool for the documentation. To build browseable HTML documentation, install the required tools provided in the `docs` dependency group:
 
-# Install the required development tools
-pip install -r requirements-dev.txt
-# Install GT4Py project in editable mode
-pip install -e .
+```bash
+uv install --group docs --extra all  # or --group dev
+```
+
+(Note that most likely these tools are already installed in your development environment, since the `docs` group is included in the `dev` group, which installed by default by `uv sync` if no dependency groups are specified.)
+
+Once the requirements are already installed, then build the docs using:
 
-# Optionally, install atlas4py bindings directly from the repo
-# pip install git+https://github.com/GridTools/atlas4py#egg=atlas4py
+```bash
+cd gt4py/docs/user/cartesian
+make html  # run 'make help' for a list of targets
 ```
 
 ## ⚖️ License