diff --git a/docs/_inc/_add-on-complete-install.md b/docs/_inc/_add-on-complete-install.md
new file mode 100644
index 000000000..e9255c5c1
--- /dev/null
+++ b/docs/_inc/_add-on-complete-install.md
@@ -0,0 +1,7 @@
+In your web browser, and assuming you are currently logged in as an administrator, visit the URL http://localhost:8080/Plone/prefs_install_products_form.
+
+Then click the {guilabel}`Install` button next to your add-on to complete installation of the add-on.
+
+Some add-ons have configuration options.
+To configure such add-ons, return to the {guilabel}`Site Setup` control panel.
+At the bottom of the page, you should see the heading {guilabel}`Add-on Configuration`, and a control panel to configure the add-on that you just installed.
diff --git a/docs/_inc/_build-and-restart.md b/docs/_inc/_build-and-restart.md
new file mode 100644
index 000000000..9a909bbab
--- /dev/null
+++ b/docs/_inc/_build-and-restart.md
@@ -0,0 +1,35 @@
+If the backend is running, stop it with {kbd}`ctrl-c`.
+
+To actually download and install the package, run the following command.
+
+`````{tab-set}
+````{tab-item} uv
+:sync: uv
+
+```shell
+make backend-build
+```
+````
+
+````{tab-item} pip
+:sync: pip
+
+```shell
+make backend-build
+```
+````
+
+````{tab-item} Buildout
+:sync: buildout
+
+```shell
+bin/buildout -N
+```
+````
+`````
+
+Next, restart the backend.
+
+```{seealso}
+{doc}`run-plone`
+```
diff --git a/docs/admin-guide/add-ons.md b/docs/admin-guide/add-ons.md
index d2f0c7e73..eb6f0a7fb 100644
--- a/docs/admin-guide/add-ons.md
+++ b/docs/admin-guide/add-ons.md
@@ -18,13 +18,23 @@ The Volto frontend has its own system of add-ons using Node.js packages.
 See {doc}`/volto/development/add-ons/index`.
 ```
 
+(install-an-add-on-from-pypi-label)=
 
-## Cookieplone
+## Install an add-on from PyPI
 
-Use the following instructions if you installed Plone with Cookieplone.
+This section describes how to install an add-on that is released on {term}`PyPI`.
 
 
-### Install an add-on
+(configure-add-on-installation-pypi-label)=
+
+### Configure add-on installation
+
+First, configure your project according to the instructions in the tabbed interface below.
+Select the tab according to the method you used to create your project.
+
+`````{tab-set}
+````{tab-item} Cookieplone
+:sync: cookieplone
 
 Add the name of your add-on in the file {file}`backend/pyproject.toml` in the section `dependencies`.
 This example adds [`collective.easyform`](https://pypi.org/project/collective.easyform/).
@@ -32,154 +42,182 @@ This example adds [`collective.easyform`](https://pypi.org/project/collective.ea
 ```{code-block} toml
 :emphasize-lines: 6
 dependencies = [
-    "Products.CMFPlone==6.1.1",
+    "Products.CMFPlone==6.1.4",
     "plone.api",
     "plone.classicui",
     "plone.app.caching",
-    "collective.easyform==4.4.0",
+    "collective.easyform==4.5.1",
 ]
 ```
 
-```{tip}
-Including the add-on version, or "pinning a version", ensures that it won't unintentionally get upgraded in the future.
-```
-
-Also add the add-on to `zcml_package_includes` in the file {file}`backend/instance.yaml` to make sure its configuration will be loaded.
+To configure the add-on to load, in the file {file}`backend/instance.yaml`, under the key `default_context`, for the key `zcml_package_includes`, set its value to the add-on's name.
 
 ```yaml
 default_context:
     zcml_package_includes: project_title, collective.easyform
 ```
+````
 
-Stop the backend with {kbd}`ctrl-c`.
+````{tab-item} Buildout
+:sync: buildout
 
-To actually download and install the new add-on, run the following command.
+Update the file {file}`buildout.cfg`.
+This example uses [`collective.easyform`](https://pypi.org/project/collective.easyform/).
 
-```shell
-make backend-build
-```
+```cfg
+[buildout]
+extends =
+    https://dist.plone.org/release/6-latest/versions.cfg
 
-Now restart the backend.
+parts =
+    instance
 
-```{seealso}
-{doc}`run-plone`
+[instance]
+recipe = plone.recipe.zope2instance
+user = admin:admin
+http-address = 8080
+eggs =
+    Plone
+    collective.easyform
+
+[versions]
+collective.easyform = 4.5.1
 ```
+````
+`````
 
-In your web browser, and assuming you are currently logged in as an administrator, visit the URL http://localhost:8080/Plone/prefs_install_products_form.
+```{tip}
+You can control which version of an add-on to install through "version pinning."
 
-Then click the {guilabel}`Install` button next to your add-on to complete installation of the add-on.
+-   Specify the add-on version to avoid its unintentional upgrade.
+-   Leave it off to always install the latest version.
+```
 
-Some add-ons have configuration options.
-To configure such add-ons, return to the {guilabel}`Site Setup` control panel.
-At the bottom of the page, you should see the heading {guilabel}`Add-on Configuration`, and a control panel to configure the add-on that you just installed.
 
+(install-the-add-on-pypi-label)=
 
-### Install an add-on from source
+### Install the add-on
 
-An add-on can be installed from a source control system such as GitHub.
+If the backend is running, stop it with {kbd}`ctrl-c`.
 
-Add a line with the name of your add-on in the file {file}`backend/requirements.txt`.
-This example uses [`collective.easyform`](https://pypi.org/project/collective.easyform/).
+To actually download and install the new add-on, run the following command.
 
-```
-collective.easyform
-```
+`````{tab-set}
+````{tab-item} Cookieplone
+:sync: cookieplone
 
-```{note}
-When installing an add-on from source, it's best not to pin a version.
-This way you always get the version that's currently available in the source control system.
+```shell
+make backend-build
 ```
+````
 
-Next add the add-on to `zcml_package_includes` in the file {file}`backend/instance.yaml` so that its configuration will load.
+````{tab-item} Buildout
+:sync: buildout
 
-```yaml
-default_context:
-    zcml_package_includes: project_title, collective.easyform
+```shell
+bin/buildout -N
 ```
+````
+`````
 
-Finally, add the package's source to the file {file}`mx.ini`.
+Next, restart the backend.
 
-```cfg
-[collective.easyform]
-url=git@github.com:collective/collective.easyform.git
-branch=dev-branch-name
-extras=test
+```{seealso}
+{doc}`run-plone`
 ```
 
-```{seealso}
-The {file}`mx.ini` file configures a tool called {term}`mxdev`.
-See the [documentation of `mxdev` in its README.md](https://github.com/mxstack/mxdev/blob/main/README.md) for complete information.
+```{include} /_inc/_add-on-complete-install.md
 ```
 
-Stop the backend with {kbd}`ctrl-c`.
 
-To actually download and install the new add-on, run the following command.
+(install-an-add-on-from-source-label)=
 
-```shell
-make backend-build
-```
+## Install an add-on from source
 
-Now restart the backend.
+This section describes how to install an unreleased add-on from a source control system, such as GitHub.
 
-```{seealso}
-{doc}`run-plone`
-```
 
-In your web browser, and assuming you are currently logged in as an administrator, visit the URL http://localhost:8080/Plone/prefs_install_products_form.
-An upgrade step might need to be performed in the Plone control panel.
-Follow the upgrade information, if present.
-Else click the {guilabel}`Install` button to complete installation of the add-on.
+(configure-add-on-installation-source-label)=
 
+### Configure add-on installation
 
-## Buildout
+First, configure your project according to the instructions in the tabbed interface below.
+Select the tab according to your Python package manager.
 
-Use the following instructions if you installed Plone with Buildout.
+```{tip}
+For projects created with Cookieplone, select the tab labeled:
 
-### Install an add-on
+-   {guilabel}`pip` if your project has the file {file}`backend/mx.ini`
+-   {guilabel}`uv` if your project doesn't have this file
+```
 
-Update the file {file}`buildout.cfg`.
-This example uses [`collective.easyform`](https://pypi.org/project/collective.easyform/).
+`````{tab-set}
+````{tab-item} uv
+:sync: uv
 
-```cfg
-[buildout]
-extends =
-    https://dist.plone.org/release/6-latest/versions.cfg
+Clone the repository into a local directory.
+This example uses [`collective.easyform`](https://pypi.org/project/collective.easyform/).
 
-parts =
-    instance
+```shell
+git clone git@github.com:collective/collective.easyform.git
+```
 
-[instance]
-recipe = plone.recipe.zope2instance
-user = admin:admin
-http-address = 8080
-eggs =
-    Plone
-    collective.easyform
+Add the local directory to your uv project as an editable package.
 
-[versions]
-collective.easyform = 4.2.1
+```shell
+cd backend
+uv add --editable ../collective.easyform
 ```
 
-```{tip}
-Including the add-on version, or "pinning a version", ensures that it won't unintentionally get upgraded in the future.
+To configure the add-on to load, in the file {file}`backend/instance.yaml`, under the key `default_context`, for the key `zcml_package_includes`, set its value to the add-on's name.
+
+```yaml
+default_context:
+    zcml_package_includes: project_title, collective.easyform
 ```
+````
 
-To actually download and install the new add-on, run the following command.
+````{tab-item} pip
+:sync: pip
 
-```shell
-bin/buildout
+Add the name of your add-on in the file {file}`backend/pyproject.toml` in the section `dependencies`.
+This example adds [`collective.easyform`](https://pypi.org/project/collective.easyform/).
+
+```{code-block} toml
+:emphasize-lines: 6
+dependencies = [
+    "Products.CMFPlone==6.1.4",
+    "plone.api",
+    "plone.classicui",
+    "plone.app.caching",
+    "collective.easyform",
+]
 ```
 
-Then restart your instance.
+To configure the add-on to load, in the file {file}`backend/instance.yaml`, under the key `default_context`, for the key `zcml_package_includes`, set its value to the add-on's name.
 
-```{seealso}
-{doc}`run-plone`
+```yaml
+default_context:
+    zcml_package_includes: project_title, collective.easyform
 ```
 
+Finally, add the package's source to the file {file}`mx.ini`.
+
+```cfg
+[collective.easyform]
+url=git@github.com:collective/collective.easyform.git
+branch=dev-branch-name
+extras=test
+```
 
-### Install an add-on from source
+```{seealso}
+The {file}`mx.ini` file configures a tool called {term}`mxdev`.
+For an explanation of why Plone uses mxdev, see {ref}`manage-packages-mxdev-label`.
+```
+````
 
-You can install an add-on from a source control system such as GitHub.
+````{tab-item} Buildout
+:sync: buildout
 
 Update the file {file}`buildout.cfg`.
 This example uses [`collective.easyform`](https://pypi.org/project/collective.easyform/).
@@ -207,18 +245,25 @@ eggs =
 collective.easyform = git https://github.com/collective/collective.easyform.git
 ```
 
-To actually download and install the new add-on, run the following command.
+```{seealso}
+This approach uses the [`mr.developer`](https://pypi.org/project/mr.developer/) Buildout extension.
+```
 
-```shell
-bin/buildout
+````
+`````
+
+```{tip}
+When installing an add-on from source, it's best not to pin a version.
+This way you always get the version that's currently available in the source control system.
 ```
 
-Then restart your instance.
 
-```{seealso}
-{doc}`run-plone`
+(install-the-add-on-source-label)=
+
+### Install the add-on
+
+```{include} /_inc/_build-and-restart.md
 ```
 
-```{seealso}
-This approach uses the [`mr.developer`](https://pypi.org/project/mr.developer/) Buildout extension.
+```{include} /_inc/_add-on-complete-install.md
 ```
diff --git a/docs/admin-guide/override-core.md b/docs/admin-guide/override-core.md
index 7fc64f739..f428fa841 100644
--- a/docs/admin-guide/override-core.md
+++ b/docs/admin-guide/override-core.md
@@ -14,77 +14,63 @@ myst:
 Plone includes a few hundred Python packages.
 Sometimes you will need to override one or more package versions to fix a bug.
 
+## Override the version of a core Plone package
 
-## Cookieplone
+Plone's Python package dependencies are pinned to specific versions at the time a Plone release is created.
+This section describes how to override the version of one of these packages, in case you need a newer one.
 
-Use the following instructions if you installed Plone with Cookieplone.
+```{caution}
+When you override package versions, the combination of packages isn't tested by the Plone development team.
+Use at your own risk!
+```
 
+### Configure package installation
 
-### Override a core Plone package
+First, configure your project according to the instructions in the tabbed interface below.
+Select the tab according to your Python package manager.
 
-Add a version override to the file {file}`mx.ini`.
-This example uses `plone.api`.
+```{tip}
+For projects created with Cookieplone, select the tab labeled:
 
-```
-[settings]
-version-overrides =
-    plone.api==2.0.0a3
+-   {guilabel}`pip` if your project has the file {file}`backend/mx.ini`
+-   {guilabel}`uv` if your project doesn't have this file
 ```
 
-```{seealso}
-The {file}`mx.ini` file configures a tool called {term}`mxdev`.
-For an explanation of why Plone uses `mxdev`, see {ref}`manage-backend-python-packages-label`.
-```
+`````{tab-set}
+````{tab-item} uv
+:sync: uv
 
-Stop the backend with {kbd}`ctrl-c`.
-
-To actually download and install the new package version, run the following command.
+In the file {file}`pyproject.toml`, under the table `[tool.uv]`, edit `constraint-dependencies`.
+This example uses `plone.api`.
 
-```shell
-make backend-build
 ```
-
-Now restart the backend.
-
-```{seealso}
-{doc}`run-plone`
+[tool.uv]
+constraint-dependencies = [
+    "plone.api==2.0.0a3",
+]
 ```
+````
 
+````{tab-item} pip
+:sync: pip
 
-### Install a core Plone package from source
-
-You can also use `mxdev` to install core Plone packages from a source control system such as GitHub.
-
-Add the Plone package you want to check out in the file {file}`mx.ini`.
-This example uses `plone.restapi`.
+In the file {file}`backend/mx.ini`, under the `[settings]` section, add `version-overrides` setting.
+This example uses `plone.api`.
 
-```cfg
-[plone.restapi]
-url = git@github.com:plone/plone.restapi.git
-branch = main
-extras = test
 ```
-
-Stop the backend with {kbd}`ctrl-c`.
-
-To actually download and install the new package version, run the following command.
-
-```shell
-make backend-build
+[settings]
+version-overrides =
+    plone.api==2.0.0a3
 ```
 
-Now restart the backend.
-
 ```{seealso}
-{doc}`run-plone`
+The {file}`mx.ini` file configures a tool called {term}`mxdev`.
+For an explanation of why Plone uses mxdev, see {ref}`manage-packages-mxdev-label`.
 ```
+````
 
-
-## Buildout
-
-Use the following instructions if you installed Plone with Buildout.
-
-### Override a core Plone package
+````{tab-item} Buildout
+:sync: buildout
 
 Update the file {file}`buildout.cfg`.
 This example uses `plone.api`.
@@ -109,25 +95,74 @@ plone.api = 2.0.0a3
 ```
 
 ```{note}
-The version pins specified in the `[versions]` section will take precedence over the pins inherited from `https://dist.plone.org/release/6-latest/versions.cfg`.
+The version pins specified in the `[versions]` section will take precedence over the pins inherited from https://dist.plone.org/release/6-latest/versions.cfg.
+```
+````
+`````
+
+### Install the package
+
+```{include} /_inc/_build-and-restart.md
 ```
 
-To actually download and install the new package version, run the following command.
+## Install a core Plone package from source
+
+A core Plone package can be installed from a source control system such as GitHub.
+This is useful for developing and testing changes in core Plone packages.
+
+### Configure package installation
+
+First, configure your project according to the instructions in the tabbed interface below.
+Select the tab according to your Python package manager.
+
+```{tip}
+For projects created with Cookieplone, select the tab labeled:
+
+-   {guilabel}`pip` if your project has the file {file}`backend/mx.ini`
+-   {guilabel}`uv` if your project doesn't have this file
+```
+
+`````{tab-set}
+````{tab-item} uv
+:sync: uv
+
+This example uses `plone.restapi`.
+
+Clone the repository into a local directory.
 
 ```shell
-bin/buildout
+git clone git@github.com:plone/plone.restapi.git
 ```
 
-Then restart your instance.
+Add the local directory to your uv project as an editable package.
 
-```{seealso}
-{doc}`run-plone`
+```shell
+cd backend
+uv add --editable ../plone.restapi
 ```
+````
 
+````{tab-item} pip
+:sync: pip
 
-### Install a core Plone package from source
+Add the Plone package you want to check out in the file {file}`backend/mx.ini`.
+This example uses `plone.restapi`.
 
-A core Plone package can be installed from a source control system such as GitHub.
+```cfg
+[plone.restapi]
+url = git@github.com:plone/plone.restapi.git
+branch = main
+extras = test
+```
+
+```{seealso}
+The {file}`mx.ini` file configures a tool called {term}`mxdev`.
+For an explanation of why Plone uses mxdev, see {ref}`manage-packages-mxdev-label`.
+```
+````
+
+````{tab-item} Buildout
+:sync: buildout
 
 Update the file {file}`buildout.cfg`.
 This example uses `plone.restapi`.
@@ -161,18 +196,13 @@ plone.restapi =
 Setting an empty version ensures that the copy of `plone.restapi` from source control will be used, instead of the version pin inherited from https://dist.plone.org/release/6-latest/versions.cfg.
 ```
 
-To actually download and install the new add-on, run the following command.
-
-```shell
-bin/buildout
-```
-
-Then restart your instance.
-
 ```{seealso}
-{doc}`run-plone`
+This approach uses the [`mr.developer`](https://pypi.org/project/mr.developer/) Buildout extension.
 ```
+````
+`````
 
-```{seealso}
-This approach uses the [`mr.developer`](https://pypi.org/project/mr.developer/) Buildout extension.
+### Install the package
+
+```{include} /_inc/_build-and-restart.md
 ```
diff --git a/docs/conceptual-guides/make-backend-build.md b/docs/conceptual-guides/make-backend-build.md
index a51a932ff..bdb084ae7 100644
--- a/docs/conceptual-guides/make-backend-build.md
+++ b/docs/conceptual-guides/make-backend-build.md
@@ -18,8 +18,8 @@ The `Makefile` at the root of your project invokes commands in `backend/Makefile
 The command `make backend-build` performs the following tasks.
 
 -   Invokes the target `install` in `backend/Makefile`.
--   `install` has the two dependencies `$(VENV_FOLDER)` and `config`.
--   `$(VENV_FOLDER)` creates and populates a virtual Python environment with uv from a {file}`constraints.txt` file generated using mxdev.
--   `config` creates the Zope and Plone configuration files using cookiecutter-zope-instance.
+-   `install` has the two dependencies `sync` and `config`.
+-   `sync` runs `uv sync` to install the project as defined in {file}`pyproject.toml`.
+-   `config` creates the Zope and Plone configuration files using {term}`cookiecutter-zope-instance`.
 
 You can configure your Zope instance as described in the section {doc}`/admin-guide/configure-zope`.
diff --git a/docs/conceptual-guides/package-management.md b/docs/conceptual-guides/package-management.md
index 595c0637b..e488a89f7 100644
--- a/docs/conceptual-guides/package-management.md
+++ b/docs/conceptual-guides/package-management.md
@@ -4,14 +4,14 @@ myst:
     "description": "Package management in Plone."
     "property=og:description": "Package management in Plone."
     "property=og:title": "Package management"
-    "keywords": "Plone 6, package management, mxdev"
+    "keywords": "Plone 6, package management, pip, uv, mxdev"
 ---
 
 # Package management
 
 Plone 6 consists of a collection of Python and Node.js packages.
 Over the decades of its existence, Plone has used several package management tools, sometimes multiple tools at one time.
-Each one has its strengths and weaknesses for performing specific tasks, such as installation, conflict resolution, updates and upgrades, and working with virtual environments and across platforms.
+Each one has its strengths and weaknesses for performing specific tasks, such as installation, conflict resolution, updates, upgrades, and working with virtual environments and across platforms.
 
 With Volto as the default frontend in Plone 6, first npm, then pnpm, was brought into the mix as a package manager for its Node.js packages.
 
@@ -24,41 +24,79 @@ Python itself has a complex and convoluted history with package management, as [
 ```
 
 
-(manage-backend-python-packages-label)=
-
 ## Manage backend Python packages
 
-If you want to check out a Plone core package for development, or want to override the constraints of Plone, normally you would define constraints with a file {file}`constraints.txt` to tell `pip` to install a different version of a Plone package.
+uv, pip with mxdev, and buildout are supported tools to manage the Python packages in the Plone backend.
+The following sections explain each of these tools in more detail.
+
+
+### uv
+
+{term}`uv` is a package manager which is popular for its speed, its ability to manage the installation of Python itself, and its ability to consistently reproduce installed packages using a {file}`uv.lock` file.
+
+When a project is fully managed using uv, it is configured in its {file}`pyproject.toml` file, and its packages are installed using `uv sync`.
+
+uv also has a [pip interface](https://docs.astral.sh/uv/pip/), and installs packages into a virtual environment via the command `uv pip install`.
+
+If you create a Plone project using Cookieplone, it creates a backend managed by uv.
+
+
+### pip
+
+By convention in the Python community, {term}`pip` is commonly used to install Python packages.
+It is one supported way to install the Plone backend.
+
+Each Plone version requires specific versions of many different packages.
+So, pip should be used with constraints to make sure the correct versions are installed.
+For example:
 
-```text
-# constraints.txt with unresolvable version conflict
--c https://dist.plone.org/release/6.0.9/constraints.txt
-plone.api>=2.1.0
+```shell
+bin/pip install -c https://dist.plone.org/release/6.1-latest/constraints.txt Plone
 ```
 
-Unfortunately `pip` does not allow overriding constraints this way.
-{term}`mxdev` solves this issue.
+In the Plone community, constraints are sometimes called "version pins."
+
+As a best practice, pip should always be used inside a specific Python {term}`virtual environment` to keep the packages separate from other applications.
+
+(manage-packages-mxdev-label)=
 
+### mxdev
 
-### `mxdev` to the rescue!
+During development, it is sometimes necessary to override the Plone version constraints.
+This makes it possible to:
+- {ref}`install a newer version of a core Plone package that was released to PyPI <install-an-add-on-from-pypi-label>` with a bugfix
+- {ref}`install an unreleased core Plone package from a source control system <install-an-add-on-from-source-label>`
 
-`mxdev` resolves Plone constraints according to your needs for pinning versions or source checkouts.
+pip does not allow overriding constraints this way.
+{term}`mxdev` solves this issue.
+
+mxdev resolves Plone constraints according to your needs for pinning versions or source checkouts.
 It reads its configuration file {file}`mx.ini`, and your {file}`requirements.txt` and {file}`constraints.txt` files.
 Then it fetches the requirements and constraints of Plone.
 Finally, it writes new combined requirements in {file}`requirements-mxdev.txt` and new constraints in {file}`constraints-mxdev.txt`.
 Together these two files contain the combined requirements and constraints, but modified according to the configuration in {file}`mx.ini`.
 The generated files indicate from where the constraints were fetched, and comments are added when a modification was necessary.
 
-`mxdev` does not run `pip` or install packages.
+mxdev does not run pip or install packages.
 You or your development tools, such as GNU Make, must perform that step.
 
 ```{seealso}
 {doc}`/admin-guide/add-ons`
 ```
 
+### buildout
+
+{term}`Buildout` is a tool for installing Python packages that has been used in the Plone community since about 2007, and is still preferred by some members of the community.
+
+It not only installs packages, but can set up other things using an extensible system of "recipes."
+
+Buildout does not install Python packages into a virtual environment.
+Instead, it creates scripts that add the necessary packages to `sys.path` before running the script target.
+
 
 ## Manage frontend Node.js packages
 
-```{todo}
-Why do we use pnpm?
-```
+Plone uses {term}`pnpm` to install Node.js packages.
+
+Compared to the standard {term}`npm`, it has features that help with developing multiple Node.js packages in the same workspace.
+In Plone, this is used to manage the installation of your project add-on alongside Volto core and other add-ons.
diff --git a/docs/glossary.md b/docs/glossary.md
index 45e1b9110..1ee4f8e3c 100644
--- a/docs/glossary.md
+++ b/docs/glossary.md
@@ -88,7 +88,7 @@ NFS
     [Network File System](https://en.wikipedia.org/wiki/Network_File_System).
 
 
-NPM
+npm
     npm is a package manager for the JavaScript programming language.
     It is the default package manager for the JavaScript runtime environment Node.js.
     Also a registry of JavaScript packages, similar to PyPI.
@@ -104,6 +104,9 @@ pyenv
     Python version management.
     [pyenv](https://github.com/pyenv/pyenv) lets you easily switch between multiple versions of Python.
 
+PyPI
+    The [Python Package Index](https://pypi.org/) is a repository of software for the Python programming language.
+
 uv
     [uv](https://docs.astral.sh/uv/) is a Python package and project manager, written in Rust.
 
@@ -964,4 +967,20 @@ Plate
     [Plate](https://platejs.org/) is a {term}`Slate`-based editor, introduced in Seven.
     Plate has a large community and provides a rich set of plugins to customize the editor experience.
     Key features include the single page editor, as well as AI integration.
+
+virtual environment
+    A virtual environment is an isolated Python environment with its own set of installed packages.
+    A virtual environment is created on top of an existing Python installation, known as the virtual environment's "base" Python, and by default is isolated from the packages in the base environment, so that only those explicitly installed in the virtual environment are available.
+    
+    ```{seealso}
+    -   {term}`virtualenv`
+    -   {term}`venv`
+    ```
+
+virtualenv
+    [`virtualenv`](https://virtualenv.pypa.io/en/latest/) is a tool to create isolated Python environments.
+    Since Python 3.3, a subset of it has been integrated into the standard library under the {term}`venv` module.
+
+venv
+    The {mod}`venv` module in the Python standard library supports creating lightweight {term}`virtual environment`s, each with their own independent set of Python packages installed in their {file}`site-packages` directories.
 ```
diff --git a/docs/overview/index.md b/docs/overview/index.md
index 5601a2e54..a6e9ddb78 100644
--- a/docs/overview/index.md
+++ b/docs/overview/index.md
@@ -114,8 +114,7 @@ Our documentation contains setup examples for these services, yet requires that
 One of the key benefits of the new React-based frontend for Plone 6 is that you can now customize and theme Plone extensively using HTML, CSS, and JavaScript using up-to-date frontend technologies without having to set up a local Python development environment.
 The Plone backend can be run on a local developer machine in a container.
 
-Basic familiarity with programming in Python and managing Python modules and packages using `virtualenv` and `pip` is required to work on the backend code.
-We use `venv` and {term}`mxdev` to manage the source installation of packages in Plone 6.
+Basic familiarity with programming in Python and managing Python modules and packages using {term}`pip` or {term}`uv` is required to work on the backend code.
 
 Similarly, to develop for the new React frontend, you need to have some experience with setting up Node.js, using a tool like {term}`nvm` to isolate your setup, and familiarity with {term}`pnpm` and {term}`React`.
 
diff --git a/styles/config/vocabularies/Plone/accept.txt b/styles/config/vocabularies/Plone/accept.txt
index b3666e096..c0b583ac1 100644
--- a/styles/config/vocabularies/Plone/accept.txt
+++ b/styles/config/vocabularies/Plone/accept.txt
@@ -10,24 +10,28 @@ backport(ed|ing)
 Barceloneta
 [Bb]oolean
 bugfix
-buildout
+[Bb]uildout
 cacheable
 Classic UI
+CMSs
 CMSUI
 CommonJS
 Cookieplone
 doctest
 ETags?
+extranets
 [Ff]avicon
 folderish
 fieldset
 getter
+interoperate
 JavaScript
 [Jj]enkins
 jQuery
 libxslt
 middleware
 Mockup
+mxdev
 namespaces?
 npm
 nvm
@@ -39,6 +43,7 @@ PLIP(s)
 Plone
 plonecli
 pluggab(le|ility)
+pnpm
 [Pp]ortlets?
 prerendered
 programatically
@@ -67,4 +72,5 @@ Volto
 Vue
 webpack
 wireframe
+xkcd
 Zope