diff --git a/EULA.md b/EULA.md
index 378366f75..5bc9b2d74 100644
--- a/EULA.md
+++ b/EULA.md
@@ -7,7 +7,7 @@ https://napari.org.
 
 <!-- Links -->
 
-[napari_installers]: https://napari.org/stable/index.html#installation
+[napari_installers]: https://napari.org/stable/tutorials/fundamentals/installation.html
 
 <!-- List of EULAs starts here -->
 <!--
diff --git a/docs/community/governance.md b/docs/community/governance.md
index bd105d120..b8fef1b56 100644
--- a/docs/community/governance.md
+++ b/docs/community/governance.md
@@ -74,7 +74,7 @@ developer community (including the SC members) fails to reach such a consensus
 in a reasonable timeframe, the SC is the entity that resolves the issue.
 
 Members of the SC also have the "owner" role within the [napari GitHub organization](https://github.com/napari)
-and are ultimately responsible for managing the napari GitHub account, the [@napari_imaging](https://twitter.com/napari_imaging)
+and are ultimately responsible for managing the napari GitHub account, the [@napari_imaging](https://x.com/napari_imaging)
 twitter account, the [napari website](https://napari.org), and other similar napari owned resources.
 
 The SC will be no less than three members and no more than five members,
diff --git a/docs/community/mission_and_values.md b/docs/community/mission_and_values.md
index 9a187af72..76998e9cc 100644
--- a/docs/community/mission_and_values.md
+++ b/docs/community/mission_and_values.md
@@ -76,4 +76,4 @@ As noted above, we'll be beginning to actively work on the plugin infrastructure
 
 ## Acknowledgements
 
-We share a lot of our mission and values with the `scikit-image` project with whom we share founding members, and acknowledge the influence of their [mission and values statement](https://scikit-image.org/docs/dev/values.html) on this document.
+We share a lot of our mission and values with the `scikit-image` project with whom we share founding members, and acknowledge the influence of their [mission and values statement](https://scikit-image.org/docs/stable/about/values.html) on this document.
diff --git a/docs/community/team.md b/docs/community/team.md
index b11a1f249..8a0514df7 100644
--- a/docs/community/team.md
+++ b/docs/community/team.md
@@ -47,7 +47,7 @@ You can read a full history of the project’s founding and early development in
 
 Over time, napari has grown to over 80 direct contributors. Talley Lambert, from Harvard Medical School, began contributing around the time of Juan's blog post, and has been a critical driver of napari's development ever since. We have core developers located in three continents and three biweekly community calls spread across the day to try to accommodate users and contributors in any time zone.
 
-Read more about napari’s [mission and values](https://napari.org/community/mission_and_values.html), how to get started as a [contributor](https://napari.org/developers/contributing.html) or join us in our [zulip chat](https://napari.zulipchat.com/login/) for a more synchronous conversation. You can also follow us on [twitter](https://twitter.com/napari_imaging).
+Read more about napari’s [mission and values](https://napari.org/community/mission_and_values.html), how to get started as a [contributor](https://napari.org/developers/contributing.html) or join us in our [zulip chat](https://napari.zulipchat.com/login/) for a more synchronous conversation. You can also follow us on [twitter](https://x.com/napari_imaging).
 
 ## Institutional and funding Partners
 
diff --git a/docs/conf.py b/docs/conf.py
index ab41f4d30..a4abfead3 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -410,12 +410,23 @@ def get_attributes(item, obj, modulename):
 autosummary_ignore_module_all = False
 
 linkcheck_anchors_ignore = [r'^!', r'L\d+-L\d+', r'r\d+', r'issuecomment-\d+']
-
 linkcheck_ignore = [
-    'https://napari.zulipchat.com/',
-    '../_tags',
-    'https://en.wikipedia.org/wiki/Napari#/media/File:Tabuaeran_Kiribati.jpg',
+    "https://napari.zulipchat.com/",
+    "../_tags",
+    "https://en.wikipedia.org/wiki/Napari#/media/File:Tabuaeran_Kiribati.jpg",
+    "http://localhost:8000",
+    "https://datadryad.org/stash/downloads/file_stream/182482",
+    "https://github.com/napari/docs/issues/new/choose",
+    "https://github.com/napari/napari/issues/new/choose",
+    "https://github.com/napari/napari/issues/new",
+    "https://napari-hub.org",
+    "https://github.com/napari/napari/releases/latest",
+    "https://onlinelibrary.wiley.com/doi/10.1002/col.20327",
 ]
+linkcheck_allowed_redirects = {
+    r"https://youtu\.be/.*": r"https://www\.youtube\.com/.*",
+    r"https://github\.com/napari/napari/releases/download/.*": r"https://objects\.githubusercontent\.com/.*",
+}
 
 
 def rewrite_github_anchor(app, uri: str):
diff --git a/docs/developers/architecture/dir_organization.md b/docs/developers/architecture/dir_organization.md
index 2848ee08b..ffe62c855 100644
--- a/docs/developers/architecture/dir_organization.md
+++ b/docs/developers/architecture/dir_organization.md
@@ -73,7 +73,7 @@ is named `_qapp_model` inside `_qt/`).
   canvas (the canvas is a vispy object onto which you can draw 'visuals').
 * `benchmarks/` - benchmarking code, mostly for checking the performance of layers.
   It is is executed in CI and is run every Sunday. See
-  [`.github/workflows/benchmarks.yml`](https://github.com/napari/napari/tree/main/.github/workflows/benchmarks.yml)
+  [`.github/workflows/benchmarks.yml`](https://github.com/napari/napari/blob/main/.github/workflows/benchmarks.yml)
   for CI workflow details. The benchmarks can also be run locally.
 * `components/` - code that defines all components of the napari viewer, including the
   layerlist, dimensions and camera.
diff --git a/docs/developers/contributing/dev_install.md b/docs/developers/contributing/dev_install.md
index b85896834..b128d3c70 100644
--- a/docs/developers/contributing/dev_install.md
+++ b/docs/developers/contributing/dev_install.md
@@ -1,7 +1,7 @@
 (dev-installation)=
 ## Setting up a development installation
 
-In order to make changes to `napari`, you will need to [fork](https://docs.github.com/en/get-started/quickstart/contributing-to-projects#forking-a-repository) the
+In order to make changes to `napari`, you will need to [fork](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project) the
 [repository](https://github.com/napari/napari). If you are not familiar with `git`, we recommend reading up on [this guide](https://docs.github.com/en/get-started/using-git/about-git#basic-git-commands).
 
 1. Clone the forked repository to your local machine and change directories:
@@ -22,7 +22,7 @@ In order to make changes to `napari`, you will need to [fork](https://docs.githu
     ::::{tab-set}
 
     :::{tab-item} Using `conda`
-    After [installing `conda`](https://www.anaconda.com/products/distribution), create an environment called `napari-env` with Python {{ python_version }} and activate it.
+    After [installing `conda`](https://www.anaconda.com/download), create an environment called `napari-env` with Python {{ python_version }} and activate it.
 
     {{ conda_create_env }}
     :::
@@ -74,7 +74,7 @@ In order to make changes to `napari`, you will need to [fork](https://docs.githu
 
 5. We use [`pre-commit`](https://pre-commit.com) to format code with
    [`black`](https://github.com/psf/black) and lint with
-   [`ruff`](https://github.com/charliermarsh/ruff) automatically prior to each commit.
+   [`ruff`](https://github.com/astral-sh/ruff) automatically prior to each commit.
    To minimize test errors when submitting pull requests, please install `pre-commit`
    in your environment as follows:
 
@@ -88,7 +88,7 @@ In order to make changes to `napari`, you will need to [fork](https://docs.githu
    see [`black`'s documentation](https://black.readthedocs.io/en/stable/).
 
    Code will also be linted to enforce the stylistic and logistical rules specified
-   in our [`flake8` configuration](https://github.com/napari/napari/blob/main/setup.cfg), which currently ignores
+   in our [`flake8` configuration](https://github.com/napari/napari/blob/main/pyproject.toml), which currently ignores
    [E203](https://lintlyci.github.io/Flake8Rules/rules/E203.html),
    [E501](https://lintlyci.github.io/Flake8Rules/rules/E501.html),
    [W503](https://lintlyci.github.io/Flake8Rules/rules/W503.html) and
diff --git a/docs/developers/contributing/documentation/docs_deployment.md b/docs/developers/contributing/documentation/docs_deployment.md
index 0cf5a6efe..228748f0f 100644
--- a/docs/developers/contributing/documentation/docs_deployment.md
+++ b/docs/developers/contributing/documentation/docs_deployment.md
@@ -55,7 +55,7 @@ through several CI workflows detailed below.
       turn happens on every commit to the `main` branches of either
       `napari/napari` or `napari/docs`).
     - For every commit to the `gh-pages` branch of this repo, the
-      [`unversioned_pages.yml` action](https://github.com/napari/napari.github.io/blob/main/.github/workflows/unversioned_pages.yml)
+      [`unversioned_pages.yml` action](https://github.com/napari/napari.github.io/blob/gh-pages/.github/workflows/unversioned_pages.yml)
       is triggered and copies the latest contents of the index page and the dev
       folder over the "stable" version of the documentation. This ensures that
       both the landing page of the website and the developer documentation,
diff --git a/docs/developers/contributing/documentation/index.md b/docs/developers/contributing/documentation/index.md
index f8796fe30..ff8ae32d0 100644
--- a/docs/developers/contributing/documentation/index.md
+++ b/docs/developers/contributing/documentation/index.md
@@ -40,7 +40,7 @@ by either [uploading file(s) from your computer](https://docs.github.com/en/repo
 [creating and editing a new file](https://docs.github.com/en/repositories/working-with-files/managing-files/creating-new-files)
 or [editing an existing file](https://docs.github.com/en/repositories/working-with-files/managing-files/editing-files)
 on the [napari/docs](https://github.com/napari/docs) GitHub repository.
-It's best if you first [fork](https://docs.github.com/en/get-started/quickstart/fork-a-repo) the [napari/docs](https://github.com/napari/docs) repository to your own GitHub account, create a [feature branch](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-and-deleting-branches-within-your-repository#creating-a-branch), upload/create/edit files through the GitHub web interface, and then [open a pull request from your fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) back to [napari-docs](https://github.com/napari/docs).
+It's best if you first [fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo) the [napari/docs](https://github.com/napari/docs) repository to your own GitHub account, create a [feature branch](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-and-deleting-branches-within-your-repository#creating-a-branch), upload/create/edit files through the GitHub web interface, and then [open a pull request from your fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) back to [napari-docs](https://github.com/napari/docs).
 
 You will also be able to [preview the documentation](doc_view_ci) as it would appear on [napari.org](https://napari.org/dev) by
 using the `Check the rendered docs here!` action at the bottom of your PR which will go to a preview site on [CircleCI](https://circleci.com/).
@@ -487,7 +487,7 @@ If you are using an IDE, it is likely that it will not use Git Bash by default.
 Alternatively, you can install WSL, which will allow you to run a Linux environment directly on Windows (without any virtual machines, etc.). You need to have Windows 10 version 2004 and higher or Windows 11. Then you can run scripts and command line utilities, as well as python and napari from for example Ubuntu on your Windows machine.
 
 1. Install the [Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/install) and [choose a linux distribution](https://learn.microsoft.com/en-us/windows/wsl/install#change-the-default-linux-distribution-installed).
-We will use Ubuntu for this guide since it is the default WSL distribution, easy to install, and works well with [WSLg](https://github.com/microsoft/wslg). The default method to perform this installation is to run `wsl --install -d Ubuntu` from command prompt as an administrator but you can refer to the [guide](https://docs.microsoft.com/en-us/windows/wsl/install-win10) for other installation methods.
+We will use Ubuntu for this guide since it is the default WSL distribution, easy to install, and works well with [WSLg](https://github.com/microsoft/wslg). The default method to perform this installation is to run `wsl --install -d Ubuntu` from command prompt as an administrator but you can refer to the [guide](https://learn.microsoft.com/en-us/windows/wsl/install) for other installation methods.
 2. Restart your computer. On restart, you will be prompted to create a user account for WSL. This account is separate from your Windows account, but you can use the same username and password if you wish.
 3. [Open up the Ubuntu distribution](https://learn.microsoft.com/en-us/windows/wsl/install#ways-to-run-multiple-linux-distributions-with-wsl) via the `Ubuntu` command and run `sudo apt update && sudo apt upgrade` to update the distribution.
 4. Install a napari development environment in Ubuntu following the [contributor guide](dev-installation) and activate the virtual environment that napari was installed into.
diff --git a/docs/developers/contributing/index.md b/docs/developers/contributing/index.md
index 4bf587b24..16932fd15 100644
--- a/docs/developers/contributing/index.md
+++ b/docs/developers/contributing/index.md
@@ -17,7 +17,7 @@ The first step to make changes to napari is to
 set up a [napari development installation](dev-installation).
 
 You can then use git to save your changes and open a
-[pull-request](https://docs.github.com/en/get-started/quickstart/contributing-to-projects#making-a-pull-request) (PR) via the following steps:
+[pull-request](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project) (PR) via the following steps:
 
 1. Make and save your changes:
 
@@ -46,7 +46,7 @@ To set it, use `git config --global user.email your-address@example.com`.
 2. Share your changes:
 
 To push the local changes in your new feature branch to your
-[forked](https://docs.github.com/en/get-started/quickstart/contributing-to-projects#forking-a-repository) repository:
+[forked](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project#forking-a-repository) repository:
 
 ```sh
 git push -u origin your-branch-name
@@ -63,7 +63,7 @@ git remote -vv
 ```
 
 You can then make a
-[PR](https://docs.github.com/en/get-started/quickstart/contributing-to-projects#making-a-pull-request) to `napari`'s `main` branch.
+[PR](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project#making-a-pull-request) to `napari`'s `main` branch.
 
 ## napari contribution guides
 
diff --git a/docs/developers/contributing/testing.md b/docs/developers/contributing/testing.md
index 2e9b9320b..d94b79360 100644
--- a/docs/developers/contributing/testing.md
+++ b/docs/developers/contributing/testing.md
@@ -304,7 +304,7 @@ you patch or replace parts of the code being tested with "fake" behavior or
 return values, so that you can test how a given function would perform *if* it
 were to receive some value from the upstream code.  For a few examples of using
 mocks when testing napari, search the codebase for
-[`unittest.mock`](https://github.com/napari/napari/search?q=%22unittest.mock%22&type=Code)
+[`unittest.mock`](https://github.com/search?q=repo%3Anapari%2Fnapari+%22unittest.mock%22&type=Code)
 
 ## Known issues
 
diff --git a/docs/developers/coredev/core_dev_guide.md b/docs/developers/coredev/core_dev_guide.md
index eafd6fa10..f386b963f 100644
--- a/docs/developers/coredev/core_dev_guide.md
+++ b/docs/developers/coredev/core_dev_guide.md
@@ -180,7 +180,7 @@ As a core member, you should be familiar with the following napari guides:
 ### Social resources
 
 - [#napari on image.sc](https://forum.image.sc/tag/napari).
-- [#napari](https://twitter.com/search?q=%23napari&f=live) and [@napari_imaging](https://twitter.com/napari_imaging) on twitter.
+- [#napari](https://x.com/search?q=%23napari&f=live) and [@napari_imaging](https://x.com/napari_imaging) on twitter.
 - [napari zulip](https://napari.zulipchat.com/) community chat channel.
 
 You are not required to monitor the social resources.
diff --git a/docs/developers/coredev/maintenance.md b/docs/developers/coredev/maintenance.md
index 73c55a4a3..da400360e 100644
--- a/docs/developers/coredev/maintenance.md
+++ b/docs/developers/coredev/maintenance.md
@@ -12,7 +12,7 @@ But this requires additional actions by core devs.
 
 
 To get automatically running workflows, we need to create a personal access token (PAT) and add it to the repository secrets.
-For security reasons, it is recommended to create a [fine-grained token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token#creating-a-fine-grained-personal-access-token). It allows us to provide only the required permissions.
+For security reasons, it is recommended to create a [fine-grained token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens). It allows us to provide only the required permissions.
 
 The token should have a one-year expiration date. After that, it needs to be refreshed.
 
diff --git a/docs/developers/coredev/packaging.md b/docs/developers/coredev/packaging.md
index 2451d8c9f..57ab4320e 100644
--- a/docs/developers/coredev/packaging.md
+++ b/docs/developers/coredev/packaging.md
@@ -251,7 +251,7 @@ Generating a `conda`-based installer requires several components in place:
 [4]: https://github.com/pypa/gh-action-pypi-publish
 [6]: https://github.com/conda/constructor
 [7]: https://conda.github.io/constructor/construct-yaml/
-[8]: https://conda-forge.org/docs/maintainer/updating_pkgs.html#rerendering-feedstocks
+[8]: https://conda-forge.org/docs/maintainer/updating_pkgs/#rerendering-feedstocks
 [16]: https://github.com/conda-forge/napari-feedstock/pulls?q=is%3Apr+sort%3Aupdated-desc+is%3Aclosed
 [17]: https://anaconda.org/napari
 [19]: https://nsis.sourceforge.io/Main_Page
diff --git a/docs/developers/coredev/release.md b/docs/developers/coredev/release.md
index b96602d5d..8b5b2cfe8 100644
--- a/docs/developers/coredev/release.md
+++ b/docs/developers/coredev/release.md
@@ -55,7 +55,7 @@ Additional `release` dependencies (`python -m pip install -e .[release]`) are re
 The `napari/napari` repository must have a PyPI API token as a GitHub secret.
 This likely has been done already, but if it has not, follow
 [this guide](https://pypi.org/help/#apitoken) to gain a token and
-[this guide](https://docs.github.com/en/actions/security-guides/encrypted-secrets)
+[this guide](https://docs.github.com/en/actions/security-for-github-actions/security-guides/using-secrets-in-github-actions)
 to add it as a secret.
 
 ## Determining the version
diff --git a/docs/developers/index.md b/docs/developers/index.md
index ca93c790f..48a60e0b8 100644
--- a/docs/developers/index.md
+++ b/docs/developers/index.md
@@ -37,6 +37,6 @@ There are a number of ways to contact the napari community:
 - [zulip](https://napari.zulipchat.com/): the zulip napari community chat channel.
 - [GitHub issue](https://github.com/napari/napari/issues): feel free to open an
   issue in our GitHub repository. Issues and pull-requests are written in [Markdown](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/about-writing-and-formatting-on-github). You can find a comprehensive guide [here](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax)
-- [Image.sc forum](https://forum.image.sc/tags/napari): napari is a community partner
+- [Image.sc forum](https://forum.image.sc/tag/napari): napari is a community partner
   on the Image.sc forum. All usage support requests should be posted on the forum with
   the tag "napari".
diff --git a/docs/further-resources/glossary.md b/docs/further-resources/glossary.md
index db3b7bbbb..4bf05c126 100644
--- a/docs/further-resources/glossary.md
+++ b/docs/further-resources/glossary.md
@@ -3,20 +3,20 @@
 | napari term        | description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | synonym/closely related term                                                |
 |--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|
 | canvas             | The canvas in the center of napari viewer contains the visual display of the data passed to napari, including images, points, shapes, and other supported data types.                                                                                                                                                                                                                                                                                                                                                                                                                        |                                                                             |
-| channel            | A channel is an image where each pixel only contains its intensity value (i.e. grayscale image). In fluorescence microscopy, each channel corresponds to a range of wavelengths. An RGB image from digital camera consists of 3 channels - red, green, blue (RGB). In napari, an image dimension that is not spatial or temporal can be considered as channels, and is typically represented as individual [image layer](https://napari.org/stable/howtos/layers/image.html). See also [this wiki page](https://en.wikipedia.org/wiki/Channel_(digital_image)) for specific examples.       | raster band in geoscience                                                   |
+| channel            | A channel is an image where each pixel only contains its intensity value (i.e. grayscale image). In fluorescence microscopy, each channel corresponds to a range of wavelengths. An RGB image from digital camera consists of 3 channels - red, green, blue (RGB). In napari, an image dimension that is not spatial or temporal can be considered as channels, and is typically represented as individual [image layer](layers-image). See also [this wiki page](https://en.wikipedia.org/wiki/Channel_(digital_image)) for specific examples.       | raster band in geoscience                                                   |
 | colormap           | A colormap represents the value of each pixel as a particular color. In fluorescence microscopy, the colormap can be selected to mirror the color of the collected wavelength. In other applications, colormaps can be used to provide the visual representation of the measured signal. There are many different types of colormaps available, see [choosing colormaps in matplotlib](https://matplotlib.org/stable/tutorials/colors/colormaps.html).                                                                                                                                                                                                                                                                                                                                                                    | look up table, LUT                                                          |
-| event              | Events and connections are a way to tell napari "If this event occurs, then call this function". [Hooking up your own events](https://napari.org/stable/howtos/extending/connecting_events.html).                                                                                                                                                                                                                                                                                               |                                                                             |
-| hook               | Hooks are places in napari where plugins can offer extended functionality. See the [napari hook specification reference](https://napari.org/stable/plugins/npe1.html#hook-specification-reference) in the [napari plugin documentation](https://napari.org/stable/plugins/index.html).                                                                                                                                                                                                                                                                                               |                                                                             |
-| hook specification | A function signature that defines the application programming interface (API) that a plugin developer must adhere to when writing the function that napari promises to call somewhere in the napari codebase. See also [napari hook specifications](https://napari.org/stable/plugins/npe1.html#hook-specification-reference).                                                                                                                                                                                                                                                                             |                                                                             |
-| keybinding         | The specific key or key combination that when pressed causes some function to occur. For example, command/control + C triggers "copy" in many operating systems. You can make your own custom keybindings, see this page on [hooking up your own events](https://napari.org/stable/howtos/extending/connecting_events.html).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | keyboard short cut                                                          |
-| mousebinding       | The specific mouse move, click, or drag event that causes some function to occur. You can make your own custom mousebindings, see this page on [hooking up your own events](https://napari.org/stable/howtos/extending/connecting_events.html).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | mouse short cut                                                             |
-| layer              | Layers are the viewable objects that can be added to napari viewer. Currently napari supports the following layers: [image](https://napari.org/stable/howtos/layers/image.html), [labels](https://napari.org/stable/howtos/layers/labels.html), [points](https://napari.org/stable/howtos/layers/points.html), [shapes](https://napari.org/stable/howtos/layers/shapes.html), [surface](https://napari.org/stable/howtos/layers/surface.html), [tracks](https://napari.org/stable/howtos/layers/tracks.html), [vectors](https://napari.org/stable/howtos/layers/vectors.html). |                                                                             |
-| label              | A label is a region of an integer image where the pixels are the same unique value. It is implemented in napari in the [labels layer](https://napari.org/stable/howtos/layers/labels.html) where each label represents a unique object, feature or classification.                                                                                                                                                                                                                                                                                                                         |                                                                             |
-| point              | A point is defined by the coordinate in space. The [points layer](https://napari.org/stable/howtos/layers/points.html)  allows you to display an NxD array of N points in D coordinates.                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                             |
-| shape              | Shapes are visual representations of N points in D coordinates. Shapes can be used as a visualization tool to indicate region of interest (ROI) or for downstream operations. In napari, the [shapes layer](https://napari.org/stable/howtos/layers/shapes.html) is a viewable object that permits visualization of the following supported shapes: rectangle, ellipses, polygons, paths, and lines.                                                                                                                                                                                                                 | [area selection tools in ImageJ](https://imagej.nih.gov/ij/docs/tools.html) |
-| surface            | A surface comprises a set of triangles (typically in three dimensions) that are connected by their common edges or corners to form the mesh. See [napari surface layer tutorial](https://napari.org/stable/howtos/layers/surface.html) for current implementation and [this wiki page](https://en.wikipedia.org/wiki/Surface_triangulation) for additional information.                                                                                                                                                                                                                    |                                                                             |
-| track              | A track describes object trajectories along the time dimension. The [tracks layer](https://napari.org/stable/howtos/layers/tracks.html) defines a track by the list containing object coordinates and the time point, with each track assigned a unique track ID.                                                                                                                                                                                                                                                                                                                              |                                                                             |
-| vector             | A vector is a line defined by its start and end positions in space. The [vectors layer](https://napari.org/stable/howtos/layers/vectors.html) renders lines onto the canvas, with input data format as Nx2xD numpy array representing N vectors in D dimensions.                                                                                                                                                                                                                                                                                                                               |                                                                             |
+| event              | Events and connections are a way to tell napari "If this event occurs, then call this function". [Hooking up your own events](connecting-events).                                                                                                                                                                                                                                                                                               |                                                                             |
+| hook               | Hooks are places in napari where plugins can offer extended functionality. See the [napari hook specification reference](hook-specifications-reference) in the [napari plugin documentation](plugins-index).                                                                                                                                                                                                                                                                                               |                                                                             |
+| hook specification | A function signature that defines the application programming interface (API) that a plugin developer must adhere to when writing the function that napari promises to call somewhere in the napari codebase. See also [napari hook specifications](hook-specifications-reference).                                                                                                                                                                                                                                                                             |                                                                             |
+| keybinding         | The specific key or key combination that when pressed causes some function to occur. For example, command/control + C triggers "copy" in many operating systems. You can make your own custom keybindings, see this page on [hooking up your own events](connecting-events).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | keyboard short cut                                                          |
+| mousebinding       | The specific mouse move, click, or drag event that causes some function to occur. You can make your own custom mousebindings, see this page on [hooking up your own events](connecting-events).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | mouse short cut                                                             |
+| layer              | Layers are the viewable objects that can be added to napari viewer. Currently napari supports the following layers: [image](layers-image), [labels](layers-labels), [points](layers-points), [shapes](layers-shapes), [surface](layers-surface), [tracks](layers-tracks), [vectors](layers-vectors). |                                                                             |
+| label              | A label is a region of an integer image where the pixels are the same unique value. It is implemented in napari in the [labels layer](layers-labels) where each label represents a unique object, feature or classification.                                                                                                                                                                                                                                                                                                                         |                                                                             |
+| point              | A point is defined by the coordinate in space. The [points layer](layers-points)  allows you to display an NxD array of N points in D coordinates.                                                                                                                                                                                                                                                                                                                                                                                                       |                                                                             |
+| shape              | Shapes are visual representations of N points in D coordinates. Shapes can be used as a visualization tool to indicate region of interest (ROI) or for downstream operations. In napari, the [shapes layer](layers-shapes) is a viewable object that permits visualization of the following supported shapes: rectangle, ellipses, polygons, paths, and lines.                                                                                                                                                                                                                 | [area selection tools in ImageJ](https://imagej.net/ij/docs/tools) |
+| surface            | A surface comprises a set of triangles (typically in three dimensions) that are connected by their common edges or corners to form the mesh. See [napari surface layer tutorial](layers-surface) for current implementation and [this wiki page](https://en.wikipedia.org/wiki/Surface_triangulation) for additional information.                                                                                                                                                                                                                    |                                                                             |
+| track              | A track describes object trajectories along the time dimension. The [tracks layer](layers-tracks) defines a track by the list containing object coordinates and the time point, with each track assigned a unique track ID.                                                                                                                                                                                                                                                                                                                              |                                                                             |
+| vector             | A vector is a line defined by its start and end positions in space. The [vectors layer](layers-vectors) renders lines onto the canvas, with input data format as Nx2xD numpy array representing N vectors in D dimensions.                                                                                                                                                                                                                                                                                                                               |                                                                             |
 | widget             | A small, composable graphical user interface component that can extend user's ability to interact with layers and other napari functions. A widget could be a simple one parameter/control (e.g. a button) or a collection of multiple controls with data output.                                                                                                                                                                                                                                                                                                                                                                                                              | [dialog in ImageJ](https://imagej.net/scripting/generic-dialog)             |
 | dock widget        | A widget that can be attached (docked) to the main napari viewer at a specified position.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                             |
-| plugin             | A napari plugin is a specialized Python package that extends napari's functionality. Examples of extended functionality include: additional file i/o support, image analysis, and other utilities. Plugin developers specify this functionality through a combination of Python entry points and a specialized manifest file. Plugins for napari can be found at [napari hub](https://www.napari-hub.org/). For a guide on how to make your own custom plugin, see [creating a napari plugin](https://napari.org/stable/plugins/index.html).                                                                                                                                                                                 |                                                                             |
+| plugin             | A napari plugin is a specialized Python package that extends napari's functionality. Examples of extended functionality include: additional file i/o support, image analysis, and other utilities. Plugin developers specify this functionality through a combination of Python entry points and a specialized manifest file. Plugins for napari can be found at [napari hub](https://www.napari-hub.org/). For a guide on how to make your own custom plugin, see [creating a napari plugin](plugins-index).                                                                                                                                                                                 |                                                                             |
diff --git a/docs/further-resources/napari-workshops.md b/docs/further-resources/napari-workshops.md
index d7d99ae49..3e4b8704d 100644
--- a/docs/further-resources/napari-workshops.md
+++ b/docs/further-resources/napari-workshops.md
@@ -42,11 +42,11 @@ or contact the core developers on [zulip chat](https://napari.zulipchat.com/logi
 
 * September 2022, Helmholtz Imaging Summer Academy
   * [Image analysis with Python and Napari](https://biapol.github.io/HIP_Introduction_to_Napari_and_image_processing_with_Python_2022/intro.html)
-  * [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7102242.svg)](https://doi.org/10.5281/zenodo.7102242)
+  * [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7102242.svg)](https://zenodo.org/records/7102242)
 
 * July 2022, SciPy 2022
   * [watch it here](https://www.youtube.com/watch?v=vismuuc4y1I&list=PLYx7XA2nY5Gfxu98P_HL1MnFb_BSkpxLV&index=10)
-  * [Workshop materials available here](https://alisterburt.github.io/napari-workshops/SciPy-0722/intro.html)
+  * [Workshop materials available here](http://alisterburt.com/napari-workshops/SciPy-0722/intro.html)
 
 * January to May 2022, [accelerator grantee plugin workshop](https://chanzuckerberg.github.io/napari-plugin-accel-workshops/)
 
@@ -63,7 +63,7 @@ or contact the core developers on [zulip chat](https://napari.zulipchat.com/logi
   * [Slide available here](https://docs.google.com/presentation/d/1sqd_CYckEwmgQO6y9VffwnmT0RSlRYIAUBixRTMYcig/view)
 
 * August 2021, [NDCN](https://chanzuckerberg.com/science/programs-resources/neurodegeneration-challenge/) Workshop / September 2021 [ZIDAS](https://www.zidas.org/) Workshop
-  * [Read the workshop materials online](https://alisterburt.github.io/napari-workshops/home.html)
+  * [Read the workshop materials online](http://alisterburt.com/napari-workshops/home.html)
   * [Workshop materials available here](https://github.com/alisterburt/napari-workshops)
 
 * June 2021, Bioimage analysis fundamentals in Python workshop at [SciPy 2021](https://www.scipy2021.scipy.org/)
diff --git a/docs/further-resources/sample_data.md b/docs/further-resources/sample_data.md
index 40c0712a5..a1c04b8e2 100644
--- a/docs/further-resources/sample_data.md
+++ b/docs/further-resources/sample_data.md
@@ -10,7 +10,7 @@ If you come across image databases that are missing from the list below, create
 |------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | [Allen Brain Atlases](http://portal.brain-map.org)                                        | Human and mouse brain atlas containing gene expression, anatomic, and genomic data                                                                                                            |
 | [Allen Cell Explorer](https://www.allencell.org)                                        | Database of cell data, segmentations, and analyses with multiple experimental parameters.                                                                                                     |
-| [Berkeley Drosophila Genome Project (BDGP) in situ database](http://insitu.fruitfly.org/cgi-bin/ex/insitu.pl) | Patterns of gene expression in Drosophila embryogenesis.                                                                                                                                      |
+| [Berkeley Drosophila Genome Project (BDGP) in situ database](https://insitu.fruitfly.org/cgi-bin/ex/insitu.pl) | Patterns of gene expression in Drosophila embryogenesis.                                                                                                                                      |
 | [The Cell Image Library](http://www.cellimagelibrary.org/home)                                     | Public resource database of images, videos, and animations of cells, capturing a wide diversity of organisms, cell types, and cellular processes.                                             |
 | [FlyLight Imagery](https://open.quiltdata.com/b/janelia-flylight-imagery)                                           | 3D fly's central nervous system captured by confocal laser scanning microscope.                                                                                                               |
 | [OpenCell](https://opencell.czbiohub.org/download)                                                   | A proteome-scale collection of protein localization and interaction measurements in human cells. Contains fluorescence microscopy and IP-MS data.                                             |
@@ -18,11 +18,11 @@ If you come across image databases that are missing from the list below, create
 | [BioImage Archive](https://www.ebi.ac.uk/biostudies/bioimages/studies)                                           | Description and data of biological studies; links to databases at EMBL-EBI (European Molecular Biology Laboratory–European Bioinformatics Institute).                                         |
 | [Image Data Resource (IDR)](https://idr.openmicroscopy.org)                                  | Public data repository for storing and integrating image data sets from published scientific studies.                                                                                         |
 | [Systems Science of Biological Dynamics (SSBD)](https://ssbd.riken.jp/database/)              | Set of quantitative data and microscopy images from a variety of species, sources, and methods.                                                                                               |
-| [Cancer Imaging Archive](https://www.cancerimagingarchive.net/collections/)                                     | Collections of cancer medical images.                                                                                                                                                         |
+| [Cancer Imaging Archive](https://www.cancerimagingarchive.net/browse-collections/)                                     | Collections of cancer medical images.                                                                                                                                                         |
 | [Brain Image Library](https://www.brainimagelibrary.org/)                                        | A public resource to deposit, analyze, mine, share, and interact with large brain image datasets.                                                                                             |
 | [EMPIAR](https://www.ebi.ac.uk/empiar/)                                                     | The Electron Microscopy Public Image Archive (EMPIAR) is a public resource for raw images underpinning 3D cryo-EM maps and tomograms.                                                         |
 | [OME-NGFF files on IDR](https://idr.github.io/ome-ngff-samples/)                                      | Catalog of IDR images formatted as OME-NGFF.                                                                                                                                                  |
-| [Cell Tracking Challenge](http://celltrackingchallenge.net/datasets)                                    | Repository of annotated videos from the Cell Tracking Challenge; contains contrast-enhancing (PhC, DIC) or fluorescence (widefield, confocal, multiphoton, and light sheet microsocopy) data. |
+| [Cell Tracking Challenge](https://celltrackingchallenge.net/datasets)                                    | Repository of annotated videos from the Cell Tracking Challenge; contains contrast-enhancing (PhC, DIC) or fluorescence (widefield, confocal, multiphoton, and light sheet microsocopy) data. |
 | [Bio-Formats supported formats](https://docs.openmicroscopy.org/bio-formats/6.9.1/supported-formats.html)                              | Example files for Bio-Formats supported formats.                                                                                                                                              |
 | [BioImage Informatics Index (BIII) datasets](http://biii.eu/dataset)                 | Mix of datasets and links to other data repositories.                                                                                                                                         |
 | [SCIFIO](https://scif.io/images/)                                                     | Example images with CC0 licenses.                                                                                                                                                             |
diff --git a/docs/guides/event_loop.md b/docs/guides/event_loop.md
index bfb646c87..941a69f35 100644
--- a/docs/guides/event_loop.md
+++ b/docs/guides/event_loop.md
@@ -19,9 +19,9 @@ connect events to "callback" functions, which essentially specifies; "If this ev
 happens, then call this function". Next you start the event loop and hope you
 connected everything correctly!  Indeed, much of the napari source code is
 dedicated to creating and handling events: search the codebase for
-[`.emit(`](https://github.com/napari/napari/search?q=%22.emit%28%22&type=code)
+[`.emit(`](https://github.com/search?q=repo%3Anapari%2Fnapari+%22.emit%28%22&type=code)
 and
-[`.connect(`](https://github.com/napari/napari/search?q=%22.connect%28%22&type=code)
+[`.connect(`](https://github.com/search?q=repo%3Anapari%2Fnapari+%22.connect%28%22&type=code)
 to find examples of creating and handling internal events, respectively.
 
 It is not necessary to have a deep understanding of event loops to use
diff --git a/docs/guides/threading.md b/docs/guides/threading.md
index 7527ec931..bb3fe3e63 100644
--- a/docs/guides/threading.md
+++ b/docs/guides/threading.md
@@ -152,6 +152,7 @@ def error_prone_function():
     ...
 ```
 
+(generators-for-the-win)=
 ## Generators for the win!
 
 ````{admonition} quick reminder
diff --git a/docs/howtos/layers/image.md b/docs/howtos/layers/image.md
index bc2e46fdc..32b2b292a 100644
--- a/docs/howtos/layers/image.md
+++ b/docs/howtos/layers/image.md
@@ -10,7 +10,7 @@ kernelspec:
   language: python
   name: python3
 ---
-(image-layer)=
+(layers-image)=
 # Using the `image` layer
 
 In this document, you will learn how to use the `napari` `image` layer,
diff --git a/docs/howtos/layers/labels.md b/docs/howtos/layers/labels.md
index f96995801..aeeb0a138 100644
--- a/docs/howtos/layers/labels.md
+++ b/docs/howtos/layers/labels.md
@@ -76,7 +76,7 @@ layer:
 
   Use this tool to manually erase a label on the `labels layer`. Other layers
   will not be affected. The label eraser tool looks like this:
-  ![image: eraser tool](../../images/labels-layer-eraser.png)
+  ![image: eraser tool](../../images/layers-labels-eraser.png)
 
 * **Paintbrush**
 
@@ -476,7 +476,7 @@ and [zarr arrays](https://zarr.readthedocs.io/en/stable/api/core.html). A
 Because the `labels` layer subclasses the `image` layer, it inherits the great
 properties of the `image` layer, like supporting lazy loading and multiscale
 images for big data layers. For more information about both these concepts see
-the details in the [image layer guide](image-layer).
+the details in the [image layer guide](layers-image).
 
 ## Creating a new labels layer
 
diff --git a/docs/howtos/layers/points.md b/docs/howtos/layers/points.md
index 6913637dc..885925c8a 100644
--- a/docs/howtos/layers/points.md
+++ b/docs/howtos/layers/points.md
@@ -10,7 +10,7 @@ kernelspec:
   language: python
   name: python3
 ---
-
+(layers-points)=
 # Using the `points` layer
 
 ```{Admonition} DEPRECATED ATTRIBUTES
diff --git a/docs/howtos/layers/shapes.md b/docs/howtos/layers/shapes.md
index f995a36b7..0741022e4 100644
--- a/docs/howtos/layers/shapes.md
+++ b/docs/howtos/layers/shapes.md
@@ -11,6 +11,7 @@ kernelspec:
   name: python3
 ---
 
+(layers-shapes)=
 # Using the `shapes` layer
 
 In this document, you will learn about the `napari` `shapes` layer, including
diff --git a/docs/howtos/layers/surface.md b/docs/howtos/layers/surface.md
index 058f7c70a..d02315ba9 100644
--- a/docs/howtos/layers/surface.md
+++ b/docs/howtos/layers/surface.md
@@ -11,6 +11,7 @@ kernelspec:
   name: python3
 ---
 
+(layers-surface)=
 # Using the `surface` layer
 
 In this document, you will learn about the `napari` `surface` layer, including
@@ -164,7 +165,7 @@ object. You can list all the available colormaps using `layer.colormaps`.
 It is also possible to create your own colormaps using vispy's
 `vispy.color.Colormap` object, see it's full
 [documentation here](https://vispy.org/api/vispy.color.colormap.html#vispy.color.colormap.Colormap).
-For more detail see the [image layer guide](image-layer).
+For more detail see the [image layer guide](layers-image).
 
 ## Adjusting contrast limits
 
@@ -172,5 +173,5 @@ The vertex values of the `surface` layer get mapped through its colormap accordi
 to values called `contrast limits`. These are a 2-tuple of values defining how
 what values get applied the minimum and maximum of the colormap and follow the
 same principles as the `contrast_limits` described in the
-[image layer guide](image-layer). They are also accessible through the same keyword
+[image layer guide](layers-image). They are also accessible through the same keyword
 arguments, properties, and GUI layer controls as in the image layer.
diff --git a/docs/howtos/layers/tracks.md b/docs/howtos/layers/tracks.md
index 3045a9ad9..b206c3c27 100644
--- a/docs/howtos/layers/tracks.md
+++ b/docs/howtos/layers/tracks.md
@@ -12,7 +12,6 @@ kernelspec:
 ---
 
 (layers-tracks)=
-
 # Using the `tracks` layer
 
 In this document, you will learn about the `napari` `tracks` layer, including
diff --git a/docs/howtos/layers/vectors.md b/docs/howtos/layers/vectors.md
index e4c6a781d..7eb53dd16 100644
--- a/docs/howtos/layers/vectors.md
+++ b/docs/howtos/layers/vectors.md
@@ -11,6 +11,7 @@ kernelspec:
   name: python3
 ---
 
+(layers-vectors)=
 # Using the `vectors` layer
 
 In this document, you will learn about the `napari` `vectors` layer, including
diff --git a/docs/naps/2-conda-based-packaging.md b/docs/naps/2-conda-based-packaging.md
index e96bb659f..06837b939 100644
--- a/docs/naps/2-conda-based-packaging.md
+++ b/docs/naps/2-conda-based-packaging.md
@@ -607,13 +607,13 @@ CC0+BY [^cc0by].
 
 [^napari-releases-json]: <https://api.github.com/repos/napari/napari/releases>
 
-[^mne-constructor]: <https://twitter.com/mne_news/status/1506212014993162247>
+[^mne-constructor]: <https://x.com/mne_news/status/1506212014993162247>
 
 [^appimage-crash]: <https://github.com/napari/napari/issues/3487>
 
 [^appimage-crash2]: <https://github.com/napari/napari/issues/3816>
 
-[^napari-packaging-docs]: <https://napari.org/stable/developers/packaging.html>
+[^napari-packaging-docs]: <napari-packaging>
 
 [^napari-hub-api]: https://api.napari-hub.org/plugins
 
@@ -625,7 +625,7 @@ CC0+BY [^cc0by].
 
 [^briefcase-python]: https://github.com/beeware?q=Python+support&type=all&language=&sort=
 
-[^pypi-parallelism-abi]: https://twitter.com/ralfgommers/status/1517410559972589569
+[^pypi-parallelism-abi]: https://x.com/ralfgommers/status/1517410559972589569
 
 [^release-guide]: https://napari.org/stable/developers/release.html
 
diff --git a/docs/naps/5-new-logo.md b/docs/naps/5-new-logo.md
index c18c2f10c..1a226ac31 100644
--- a/docs/naps/5-new-logo.md
+++ b/docs/naps/5-new-logo.md
@@ -161,7 +161,7 @@ for the logo, regardless of where this NAP lands.
 It's been suggested that the squircle shape might make it harder to tile a
 laptop together with other stickers, or align the edges. However, I think the
 tiling issue is a red herring because a quick look at the [NumFOCUS sticker
-table](https://twitter.com/NumFOCUS/status/1547651122654916609) shows that most
+table](https://x.com/NumFOCUS/status/1547651122654916609) shows that most
 related projects have irregularly-shaped stickers anyway. Additionally, I think
 that the squircle provides both a long enough straight edge (almost 1/3 of each
 side is exactly straight) to align things, but the smooth curvature makes
diff --git a/docs/naps/9-multiple-canvases.md b/docs/naps/9-multiple-canvases.md
index 31726dbd0..5fbbe276b 100644
--- a/docs/naps/9-multiple-canvases.md
+++ b/docs/naps/9-multiple-canvases.md
@@ -33,11 +33,11 @@ Current napari architecture supports a single canvas (viewbox) per viewer (windo
 The ability to view n-D data from multiple perspectives (or different data from the *same* perspective -- for example side-by-side segmentations) is a common feature request, and has proved useful in many other tools for data exploration and analysis. Here is a sampling of issues requesting support and discussing potential implementations:
 
 * [#5348](https://github.com/napari/napari/issues/5348) Multicanvas viewer
-* [#2338](https:////github.com/napari/napari/issues/2338) Multicanvas API Thoughts
-* [#760](https:////github.com/napari/napari/issues/760) Linked multicanvas support
-* [#662](https:////github.com/napari/napari/issues/662) Linked 2D views
-* [#561](https:////github.com/napari/napari/issues/561) multicanvas grid display for layers in Napari
-* [#1478](https:////github.com/napari/napari/issues/1478) Orthogonal viewer plugin
+* [#2338](https://github.com/napari/napari/issues/2338) Multicanvas API Thoughts
+* [#760](https://github.com/napari/napari/issues/760) Linked multicanvas support
+* [#662](https://github.com/napari/napari/issues/662) Linked 2D views
+* [#561](https://github.com/napari/napari/issues/561) multicanvas grid display for layers in Napari
+* [#1478](https://github.com/napari/napari/issues/1478) Orthogonal viewer plugin
 
 Several plugins and examples have been created to address these limitations, for example:
 * [napari-3d-ortho-viewer](https://github.com/gatoniel/napari-3d-ortho-viewer/tree/main)
diff --git a/docs/plugins/advanced_topics/npe1.md b/docs/plugins/advanced_topics/npe1.md
index 21e0ed385..88c20f3fe 100644
--- a/docs/plugins/advanced_topics/npe1.md
+++ b/docs/plugins/advanced_topics/npe1.md
@@ -176,7 +176,7 @@ specification in the same module or class, without needing a separate entry poin
 
 Packages and modules installed in the same environment as `napari` may make
 themselves "discoverable" to napari using package metadata, as outlined in the
-[Python Packaging Authority guide](https://packaging.python.org/guides/creating-and-discovering-plugins/#using-package-metadata).
+[Python Packaging Authority guide](https://packaging.python.org/en/latest/guides/creating-and-discovering-plugins/#using-package-metadata).
 
 By providing an `entry_points` argument with the key `napari.plugin` to
 `setup()` in `setup.py`, plugins can register themselves for discovery.
diff --git a/docs/plugins/building_a_plugin/best_practices.md b/docs/plugins/building_a_plugin/best_practices.md
index eba625a9f..29482f0f9 100644
--- a/docs/plugins/building_a_plugin/best_practices.md
+++ b/docs/plugins/building_a_plugin/best_practices.md
@@ -92,7 +92,7 @@ will run into difficulties installing your plugin:
   There's no one right way, but more often than not, if a package uses C
   extensions, the `setup()` function in their `setup.py` file will use the
   [`ext_modules`
-  argument](https://docs.python.org/3/distutils/setupscript.html#describing-extension-modules).
+  argument](https://docs.python.org/3.11/distutils/setupscript.html#describing-extension-modules).
   (for example, [see here in
   pytorch](https://github.com/pytorch/pytorch/blob/master/setup.py#L914))
 
diff --git a/docs/plugins/building_a_plugin/first_plugin.md b/docs/plugins/building_a_plugin/first_plugin.md
index 8d8fca172..a34fc85b9 100644
--- a/docs/plugins/building_a_plugin/first_plugin.md
+++ b/docs/plugins/building_a_plugin/first_plugin.md
@@ -302,7 +302,7 @@ Review the [Best Practices](best-practices) when developing plugins and,
 when you're ready to share your plugin, see [Testing and Publishing](plugin-test-deploy).
 
 [miniconda]: https://docs.conda.io/projects/conda/en/latest/user-guide/install/download.html
-[python_env]: https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html#managing-python
+[python_env]: https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-python.html
 [editable_mode]: https://pip.pypa.io/en/stable/cli/pip_install/#editable-installs
 [napari_plugin_template]: https://github.com/napari/napari-plugin-template
 [entry_points]: https://packaging.python.org/en/latest/specifications/entry-points/
diff --git a/docs/plugins/building_a_plugin/guides.md b/docs/plugins/building_a_plugin/guides.md
index e0c8f1b22..888ae020d 100644
--- a/docs/plugins/building_a_plugin/guides.md
+++ b/docs/plugins/building_a_plugin/guides.md
@@ -7,7 +7,7 @@ an example implementation. For details on the type and meaning of each
 field in a specific contribution, See the
 [contributions reference](contributions-ref)
 
-
+(plugin-readers-guide)=
 ```{include} ../_npe2_readers_guide.md
 ```
 ----------------
diff --git a/docs/plugins/testing_and_publishing/deploy.md b/docs/plugins/testing_and_publishing/deploy.md
index fc9e56c0d..42aed9562 100644
--- a/docs/plugins/testing_and_publishing/deploy.md
+++ b/docs/plugins/testing_and_publishing/deploy.md
@@ -57,7 +57,7 @@ forum](https://forum.image.sc/tag/napari).
 
 [classifier]: https://pypi.org/classifiers/
 [pypi]: https://pypi.org/
-[pypi-upload]: https://packaging.python.org/tutorials/packaging-projects/#uploading-the-distribution-archives
+[pypi-upload]: https://packaging.python.org/en/latest/tutorials/packaging-projects/#uploading-the-distribution-archives
 [hubguide]: https://github.com/chanzuckerberg/napari-hub/blob/main/docs/customizing-plugin-listing.md
 [hub-guide-custom-viz]: https://github.com/chanzuckerberg/napari-hub/wiki/Customizing-your-plugin's-listing#visibility
 [autodeploy]: https://github.com/napari/napari-plugin-template#set-up-automatic-deployments
diff --git a/docs/plugins/testing_workshop_docs/3-readers-and-fixtures.md b/docs/plugins/testing_workshop_docs/3-readers-and-fixtures.md
index 17096ed6e..64dc1c402 100644
--- a/docs/plugins/testing_workshop_docs/3-readers-and-fixtures.md
+++ b/docs/plugins/testing_workshop_docs/3-readers-and-fixtures.md
@@ -96,7 +96,7 @@ We will have access to what `write_func` returns once it’s been called inside
 
 The benefit of creating this fixture is that whenever we want to write our own test data we don't have to copy three lines of code, we can just use the fixture. This is useful in testing data with different structures like integers or a specific layer type. Those arguments could be passed to further customize your fixture.
 
-We still want to make sure we get a reader when we call `napari_get_reader` with the file. We call that `reader` function with the file we created to see if it returns what we expect. Based on the [reader spec](https://napari.org/stable/plugins/contributions.html#contributions-readers), it should return a layer data list. Here is the full test, with the fixture:
+We still want to make sure we get a reader when we call `napari_get_reader` with the file. We call that `reader` function with the file we created to see if it returns what we expect. Based on the [reader spec](plugin-readers-guide), it should return a layer data list. Here is the full test, with the fixture:
 ```python
 @pytest.fixture
 def write_im_to_file(tmp_path):
diff --git a/docs/plugins/testing_workshop_docs/testing-resources.md b/docs/plugins/testing_workshop_docs/testing-resources.md
index c3f0301f6..5d2872307 100644
--- a/docs/plugins/testing_workshop_docs/testing-resources.md
+++ b/docs/plugins/testing_workshop_docs/testing-resources.md
@@ -14,6 +14,6 @@ Important: Instances of this class should be accessed only by using a qtbot fixt
 
 * [codecov](https://about.codecov.io/) - As long as your code has tests and your coverage tool can output coverage results you can use Codecov.
 
-* [GitHub workflow docs](https://docs.github.com/en/actions/quickstart) - You need only a GitHub repository to create and run a GitHub Actions workflow.
+* [GitHub workflow docs](https://docs.github.com/en/actions/writing-workflows/quickstart) - You need only a GitHub repository to create and run a GitHub Actions workflow.
 
-* [Slides from workshop presentation](https://docs.google.com/presentation/d/1RFja0o6cZ8lAalAve8heuJ-Lrb4nOSUnfdpOSEhqqNo/) - These are the actual slides that were used during the testing workshop.
\ No newline at end of file
+* [Slides from workshop presentation](https://docs.google.com/presentation/d/1RFja0o6cZ8lAalAve8heuJ-Lrb4nOSUnfdpOSEhqqNo) - These are the actual slides that were used during the testing workshop.
diff --git a/docs/plugins/virtual_environment_docs/2-deploying-your-plugin.md b/docs/plugins/virtual_environment_docs/2-deploying-your-plugin.md
index 6109909b0..1ae82f2ff 100644
--- a/docs/plugins/virtual_environment_docs/2-deploying-your-plugin.md
+++ b/docs/plugins/virtual_environment_docs/2-deploying-your-plugin.md
@@ -90,7 +90,7 @@ jobs:
 
 ```
 
-  **Note:** Gate this action on some criterion, e.g. a git tag as above, or [some other criterion](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows).
+  **Note:** Gate this action on some criterion, e.g. a git tag as above, or [some other criterion](https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows).
 
 (deploying-to-anaconda)=
 ## Deploying to Anaconda
diff --git a/docs/plugins/virtual_environment_docs/4-developer-tools.md b/docs/plugins/virtual_environment_docs/4-developer-tools.md
index 620949e8d..82d67a8ca 100644
--- a/docs/plugins/virtual_environment_docs/4-developer-tools.md
+++ b/docs/plugins/virtual_environment_docs/4-developer-tools.md
@@ -25,7 +25,7 @@ These _check_ your code.
 These _auto-modify_ your code.
 * [black](https://github.com/psf/black)
   Forces code to follow specific style, indentations, etc...
-* [autoflake](https://github.com/myint/autoflake)
+* [autoflake](https://github.com/PyCQA/autoflake)
   Auto-fixes some flake8 failures.
 * [isort](https://github.com/PyCQA/isort)
   Auto-sorts and formats your imports.
diff --git a/docs/plugins/virtual_environment_docs/5-survey.md b/docs/plugins/virtual_environment_docs/5-survey.md
index 8248efdb6..1f580a11f 100644
--- a/docs/plugins/virtual_environment_docs/5-survey.md
+++ b/docs/plugins/virtual_environment_docs/5-survey.md
@@ -36,7 +36,7 @@ Answer:
 Question: How can we find the different signals/slots we can connect callbacks to as the user interacts with the core napari interface e.g. creating/editing/deleting a `points` or `shapes` layer?
 
 Answer:
-[https://napari.org/guides/stable/events_reference.html](https://napari.org/stable/guides/events_reference.html)
+[Events reference](events-reference)
 
 Granted, this is a work in progress.
 
@@ -61,7 +61,7 @@ Question: How do you make a process cancellable to interrupt a method that is ru
 
 Answer:
 * In single-threaded python, use `Ctrl-C`
-* In multithreaded python, there are many different patterns. Consider using a [generator-based thread worker](https://napari.org/stable/guides/threading.html#generators-for-the-win).
+* In multithreaded python, there are many different patterns. Consider using a [generator-based thread worker](generators-for-the-win).
 
 ## Are there testing environments in napari?
 Answer: Napari does not create or otherwise manage environments.
@@ -71,12 +71,12 @@ Answer:
 * The primary difference is in how plugins are discovered:
     - npe1 used decorators, requiring module import.
     - npe2 uses static manifests (`napari.yaml`), describing contributions without requiring import.
-    - See also the [Your First Plugin tutorial](https://napari.org/stable/plugins/first_plugin.html)
+    - See also the [Your First Plugin tutorial](your-first-plugin)
 
 Additional resources:
-* [Contributions Reference](https://napari.org/stable/plugins/contributions.html)
-* [Guides for each type of contribution](https://napari.org/stable/plugins/guides.html)
-* [Migration guide](https://napari.org/stable/plugins/npe2_migration_guide.html)
+* [Contributions Reference](contributions-ref)
+* [Guides for each type of contribution](plugin-contribution-guides)
+* [Migration guide](npe2-migration-guide)
 
 ## What is the optimal setup to quickly iterate in widget development?
 Answer:
diff --git a/docs/release/release_0_4_15.md b/docs/release/release_0_4_15.md
index 4131c0c31..0192d3d9e 100644
--- a/docs/release/release_0_4_15.md
+++ b/docs/release/release_0_4_15.md
@@ -37,7 +37,7 @@ If users install this third-party package, they will be presented with a
 dialog asking whether to opt-in to report errors to select napari core
 developers, which will help us prioritise and fix bugs that we might otherwise
 miss. See the project's
-[README](https://github.com/tlambert03/napari-error-reporter/#readme) for
+[README](https://github.com/tlambert03/napari-error-reporter/) for
 details.
 
 Finally, we have made some updates to how our application works. We now provide
diff --git a/docs/release/release_0_4_17.md b/docs/release/release_0_4_17.md
index 09756d95c..c2f90de9f 100644
--- a/docs/release/release_0_4_17.md
+++ b/docs/release/release_0_4_17.md
@@ -20,7 +20,7 @@ We picked out a few highlights, but keep reading below for the full list of chan
 We added a new blending mode, `minimum`, in #4875, along with some inverted colormaps by @cleterrier.
 The new mode and colormaps enable visualizing data as color intensities on a white background.
 This is particularly nice when using the Light theme.
-For more inspiration see [#invertedLUT on Twitter](https://twitter.com/hashtag/invertedLUT)
+For more inspiration see [#invertedLUT on Twitter](https://x.com/hashtag/invertedLUT)
 and the built-in napari example [examples/minimum_blending.py](https://github.com/napari/napari/blob/main/examples/minimum_blending.py).
 
 ### Option to edit second shortcut in preferences
diff --git a/docs/release/release_0_4_6.md b/docs/release/release_0_4_6.md
index 3733b2779..d5dd27f66 100644
--- a/docs/release/release_0_4_6.md
+++ b/docs/release/release_0_4_6.md
@@ -62,7 +62,7 @@ package name, url, or local file (#2319).
 
 ## API Changes
 - The ViewerModel is now a Pydantic BaseModel and so subclassing the Viewer might require
-reading some of the [Pydantic BaseModel documentation](https://pydantic-docs.helpmanual.io/usage/models/).
+reading some of the [Pydantic BaseModel documentation](https://docs.pydantic.dev/latest/usage/models/).
 Otherwise the API of the ViewerModel is unchanged.
 - Because `Labels` no longer inherit from `Image` (#2307), magicgui function
   parameters annotated as `napari.layers.Image` will no longer include
diff --git a/docs/roadmaps/0_3.md b/docs/roadmaps/0_3.md
index d6b18c36e..f6755600e 100644
--- a/docs/roadmaps/0_3.md
+++ b/docs/roadmaps/0_3.md
@@ -18,7 +18,7 @@ Once the above goals are met, we will develop napari's capabilities for image pr
 
 - **Better support for viewing big datasets**. Currently, napari is fast when viewing on-disk datasets that can be naturally sliced along one axis (e.g. a time series) *and where loading one slice is fast*. However, when the loading is slow, the napari UI itself becomes slow, sometimes to the point of being unusable. We aim to improve this by making views and interactions non-blocking ([#845](https://github.com/napari/napari/issues/845)), and improving caching ([#718](https://github.com/napari/napari/issues/718)). We will also ensure that napari can be used `headless` without the GUI.
 
-- **Improving the performance of operations on in-memory data**. Even when data is loaded in memory, some operations, such as label and shape painting, slicing along large numbers of points, or adjusting contrast and gamma, can be slow. We will continue developing our [benchmark suite](https://github.com/napari/docs/blob/main/docs/developers/benchmarks.md) and work to integrate it into our development process. See the [`performance` label](https://github.com/napari/napari/labels/performance) for a current list of issues related to performance.
+- **Improving the performance of operations on in-memory data**. Even when data is loaded in memory, some operations, such as label and shape painting, slicing along large numbers of points, or adjusting contrast and gamma, can be slow. We will continue developing our [benchmark suite](https://github.com/napari/docs/blob/main/docs/developers/contributing/performance/benchmarks.md) and work to integrate it into our development process. See the [`performance` label](https://github.com/napari/napari/labels/performance) for a current list of issues related to performance.
 
 - Add a unified **world coordinate system**. Scientists need to measure data that comes from a real space with physical dimensions. Currently, napari has no concept of the space in which data lives: everything is unitless. Further, it is unclear at various parts in the UI whether a coordinate has been transformed. And finally, some data are acquired with distortions, such as skew in data collected on stage-scanning lightsheet microscopes, and napari should be able to account for those distortions by chaining together transforms - including affine and ultimately deformable transforms. We are tracking progress in this area in the [World Coordinates project board](https://github.com/napari/napari/projects/10).
 
@@ -44,9 +44,9 @@ Once the above goals are met, we will develop napari's capabilities for image pr
 
 ## Provide accessible documentation, tutorials, and demos
 
-- Improve our website [napari.org](https://napari.org) to provide easy access to all napari related materials, including the [**four types of documentation**](https://www.divio.com/blog/documentation/): learning-oriented tutorials, goal-oriented how-to-guides or galleries, understanding-oriented explanations (including developer resources), and a comprehensive API reference. See [#764](https://github.com/napari/napari/issues/764) and the [`documentation` label](https://github.com/napari/napari/labels/documentation) on the napari repository for more details.
+- Improve our website [napari.org](https://napari.org) to provide easy access to all napari related materials, including the [**four types of documentation**](https://docs.divio.com/documentation-system/): learning-oriented tutorials, goal-oriented how-to-guides or galleries, understanding-oriented explanations (including developer resources), and a comprehensive API reference. See [#764](https://github.com/napari/napari/issues/764) and the [`documentation` label](https://github.com/napari/napari/labels/documentation) on the napari repository for more details.
 
-- Add a **napari human interface guide** for plugin developers, akin to [Apple's Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/guidelines/overview/). We want such a guide to promote best practices and ensure that plugins provide a consistent user experience.
+- Add a **napari human interface guide** for plugin developers, akin to [Apple's Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/). We want such a guide to promote best practices and ensure that plugins provide a consistent user experience.
 
 ## Work prioritized for future roadmaps
 
diff --git a/docs/roadmaps/0_3_retrospective.md b/docs/roadmaps/0_3_retrospective.md
index 9916ec034..b74811dd6 100644
--- a/docs/roadmaps/0_3_retrospective.md
+++ b/docs/roadmaps/0_3_retrospective.md
@@ -77,11 +77,11 @@ Once the above goals are met, we will develop napari's capabilities for image pr
 
 ## Provide accessible documentation, tutorials, and demos
 
-- Improve our website [napari.org](https://napari.org) to provide easy access to all napari related materials, including the [**four types of documentation**](https://www.divio.com/blog/documentation/): learning-oriented tutorials, goal-oriented how-to-guides or galleries, understanding-oriented explanations (including developer resources), and a comprehensive API reference. See [#764](https://github.com/napari/napari/issues/764) and the [`documentation` label](https://github.com/napari/napari/labels/documentation) on the napari repository for more details.
+- Improve our website [napari.org](https://napari.org) to provide easy access to all napari related materials, including the [**four types of documentation**](https://docs.divio.com/documentation-system/): learning-oriented tutorials, goal-oriented how-to-guides or galleries, understanding-oriented explanations (including developer resources), and a comprehensive API reference. See [#764](https://github.com/napari/napari/issues/764) and the [`documentation` label](https://github.com/napari/napari/labels/documentation) on the napari repository for more details.
 
     > We have begun the design work for this but have not begun the implementation yet. This work will be moved to our 0.4 series of releases.
 
-- Add a **napari human interface guide** for plugin developers, akin to [Apple's Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/guidelines/overview/). We want such a guide to promote best practices and ensure that plugins provide a consistent user experience.
+- Add a **napari human interface guide** for plugin developers, akin to [Apple's Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines). We want such a guide to promote best practices and ensure that plugins provide a consistent user experience.
 
     > We have not done this work yet, and this work will be moved to our 0.4 series of releases.
 
diff --git a/docs/roadmaps/0_4.md b/docs/roadmaps/0_4.md
index b19567e46..c4f1c4b05 100644
--- a/docs/roadmaps/0_4.md
+++ b/docs/roadmaps/0_4.md
@@ -107,7 +107,7 @@ Quality documentation is therefore high priority for the team. We aim to:
 
 - Support autogenerated screenshots and movies for our documentation to ensures it always stays up-to-date as we improve napari. These examples should also be runnable by our users to serve as training materials as they learn to use napari.
 
-- Add a **napari human interface guide** for plugin developers, akin to [Apple's Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/guidelines/overview/). We want such a guide to promote best practices and ensure that plugins provide a consistent user experience.
+- Add a **napari human interface guide** for plugin developers, akin to [Apple's Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines). We want such a guide to promote best practices and ensure that plugins provide a consistent user experience.
 
 ## Work prioritized for future roadmaps
 
diff --git a/docs/tutorials/fundamentals/getting_started.md b/docs/tutorials/fundamentals/getting_started.md
index 95e761345..d9a87ec25 100644
--- a/docs/tutorials/fundamentals/getting_started.md
+++ b/docs/tutorials/fundamentals/getting_started.md
@@ -154,7 +154,7 @@ You can also launch `napari` from a Jupyter notebook. The
 [examples gallery](../../gallery), as mentioned above, can also be downloaded as
 `.ipynb` which can be run from a Jupyter notebook.
 
-Below, we launch the [notebook example](https://github.com/napari/napari/tree/main/examples/notebook.ipynb) from a Jupyter notebook.
+Below, we launch the [notebook example](https://github.com/napari/napari/blob/main/examples/notebook.ipynb) from a Jupyter notebook.
 
 ![image: napari launched from a Jupyter notebook](../assets/tutorials/launch_jupyter.png)
 
diff --git a/docs/tutorials/fundamentals/installation.md b/docs/tutorials/fundamentals/installation.md
index aec5d0400..ba50fa8cb 100644
--- a/docs/tutorials/fundamentals/installation.md
+++ b/docs/tutorials/fundamentals/installation.md
@@ -171,8 +171,8 @@ the current release {{ napari_version }}, using the command: `napari --version`
 
 napari needs a library called [Qt](https://www.qt.io/) to run its user interface
 (UI). In Python, there are two alternative libraries to run this, called
-[PyQt5](https://www.riverbankcomputing.com/software/pyqt/download5) and
-[PySide2](https://doc.qt.io/qtforpython/). By default, we don't choose for you,
+[PyQt5](https://www.riverbankcomputing.com/software/pyqt/download) and
+[PySide2](https://doc.qt.io/qtforpython-6/). By default, we don't choose for you,
 and simply running `python -m pip install napari` will not install either. You *might*
 already have one of them installed in your environment, thanks to other
 scientific packages such as Spyder or matplotlib. If neither is available,
@@ -253,6 +253,6 @@ guidelines](napari-contributing)
 - if you are running into issues or bugs, please open a [new issue](https://github.com/napari/napari/issues/new/choose) on our [issue
 tracker](https://github.com/napari/napari/issues)
 - if you want help using napari, we are a community partner on the [imagesc
-forum](https://forum.image.sc/tags/napari) and all usage support requests should
+forum](https://forum.image.sc/tag/napari) and all usage support requests should
 be posted on the forum with the tag `napari`. We look forward to interacting
 with you there!
diff --git a/docs/tutorials/fundamentals/viewer.md b/docs/tutorials/fundamentals/viewer.md
index 0210fb21b..41d730fa0 100644
--- a/docs/tutorials/fundamentals/viewer.md
+++ b/docs/tutorials/fundamentals/viewer.md
@@ -76,7 +76,7 @@ nbscreenshot(viewer, alt_text="photograph of an astronaut in napari viewer")
 viewer.close()
 ```
 
- {func}`imshow<napari.imshow>` and the {meth}`add_image<napari.components.ViewerModel.add_image>` methods accept any numpy-array like object as input, including n-dimensional arrays. For more information on adding images to the viewer see the [image layer guide](image-layer).
+ {func}`imshow<napari.imshow>` and the {meth}`add_image<napari.components.ViewerModel.add_image>` methods accept any numpy-array like object as input, including n-dimensional arrays. For more information on adding images to the viewer see the [image layer guide](layers-image).
 
 Now we will continue exploring the rest of the viewer.
 
diff --git a/docs/tutorials/processing/dask.md b/docs/tutorials/processing/dask.md
index f5318418b..e60d382b2 100644
--- a/docs/tutorials/processing/dask.md
+++ b/docs/tutorials/processing/dask.md
@@ -194,7 +194,7 @@ for NeuroImaging of Coma and Consciousness, which is dedicated to promoting
 recovery of consciousness in people with severe brain injuries. This dataset is
 a 100 micron resolution magnetic resonance imaging (MRI) scan of an ex vivo
 human brain specimen. The brain specimen was donated by a [58-year-old woman](https://www.youtube.com/watch?v=Q-9jzBkoNuI) who had no history of neurological disease and died of non-neurological causes.
-This dataset was originally described in [Edlow, B.L., Mareyam, A., Horn, A. _et al._ 7 Tesla MRI of the ex vivo human brain at 100 micron resolution. Sci Data 6, 244 (2019)](https://doi.org/10.1038/s41597-019-0254-8).
+This dataset was originally described in [Edlow, B.L., Mareyam, A., Horn, A. _et al._ 7 Tesla MRI of the ex vivo human brain at 100 micron resolution. Sci Data 6, 244 (2019)](https://www.nature.com/articles/s41597-019-0254-8).
 
 ```{admonition} Getting the data
 
diff --git a/docs/tutorials/segmentation/annotate_segmentation.md b/docs/tutorials/segmentation/annotate_segmentation.md
index 2aae181fb..be9027491 100644
--- a/docs/tutorials/segmentation/annotate_segmentation.md
+++ b/docs/tutorials/segmentation/annotate_segmentation.md
@@ -139,7 +139,7 @@ napari.run()
 ```
 
 ## Segmentation
-We start by defining a function to perform segmentation of an image based on intensity. Based on the [skimage segmentation example](https://scikit-image.org/docs/stable/auto_examples/applications/plot_thresholding.html), we determine the threshold intensity that separates the foreground and background pixels using [Otsu's method](https://en.wikipedia.org/wiki/Otsu%27s_method). We then perform some cleanup and generate a label image where each discrete region is given a unique integer index.
+We start by defining a function to perform segmentation of an image based on intensity. Based on the [skimage segmentation example](https://scikit-image.org/docs/stable/auto_examples/applications/plot_thresholding_guide.html), we determine the threshold intensity that separates the foreground and background pixels using [Otsu's method](https://en.wikipedia.org/wiki/Otsu%27s_method). We then perform some cleanup and generate a label image where each discrete region is given a unique integer index.
 
 ```python
 def segment(image):
@@ -190,7 +190,7 @@ napari.run()
 
 ## Analyzing the segmentation
 
-Next, we use [`regionprops_table`](https://scikit-image.org/docs/dev/api/skimage.measure.html#regionprops-table) from skimage to quantify some parameters of each detection object (e.g., area and perimeter).
+Next, we use [`regionprops_table`](https://scikit-image.org/docs/dev/api/skimage.measure.html#skimage.measure.regionprops_table) from skimage to quantify some parameters of each detection object (e.g., area and perimeter).
 
 ```python
 # create the features dictionary
diff --git a/docs/tutorials/tracking/cell_tracking.md b/docs/tutorials/tracking/cell_tracking.md
index 6706f7608..8300f35a0 100644
--- a/docs/tutorials/tracking/cell_tracking.md
+++ b/docs/tutorials/tracking/cell_tracking.md
@@ -8,7 +8,7 @@ This application note covers two examples:
 
 ## 1. Cell tracking challenge data
 
-The first example of track visualization uses data from the [cell tracking challenge](http://celltrackingchallenge.net/3d-datasets/). We will use the *C. elegans* developing embryo [dataset](https://data.celltrackingchallenge.net/training-datasets/Fluo-N3DH-CE.zip) which consists of 3D+t volumetric imaging data, manually annotated tracks and cell lineage information.
+The first example of track visualization uses data from the [cell tracking challenge](https://celltrackingchallenge.net/3d-datasets/). We will use the *C. elegans* developing embryo [dataset](https://data.celltrackingchallenge.net/training-datasets/Fluo-N3DH-CE.zip) which consists of 3D+t volumetric imaging data, manually annotated tracks and cell lineage information.
 
 A full description of the data format can be found [here](https://public.celltrackingchallenge.net/documents/Naming%20and%20file%20content%20conventions.pdf).
 
@@ -193,13 +193,13 @@ napari.run()
 
 ## 2. Using `btrack` to track cells
 
-The `btrack` library can be used for cell tracking. It provides a convenient `to_napari()` function to enable rapid visualization of the tracking results. You can learn more about the `btrack` library [here](https://github.com/quantumjot/BayesianTracker).
+The `btrack` library can be used for cell tracking. It provides a convenient `to_napari()` function to enable rapid visualization of the tracking results. You can learn more about the `btrack` library [here](https://github.com/quantumjot/btrack).
 
 ```python
 import btrack
 ```
 
-We start by loading a file containing the centroids of all the found cells in each frame of the source movie. Note that this file only contains the locations of cells in the movie, there are no tracks yet. We can use the `btrack` library to load this file as a list of `objects` that contain information about each found cell, including the TZYX position.  The example dataset can be downloaded [here](https://github.com/quantumjot/BayesianTracker/blob/0f8bbd937535193bde20e3ebe91a323f6bb915e9/examples/napari_example.csv).
+We start by loading a file containing the centroids of all the found cells in each frame of the source movie. Note that this file only contains the locations of cells in the movie, there are no tracks yet. We can use the `btrack` library to load this file as a list of `objects` that contain information about each found cell, including the TZYX position.  The example dataset can be downloaded [here](https://github.com/quantumjot/btrack/blob/0f8bbd937535193bde20e3ebe91a323f6bb915e9/examples/napari_example.csv).
 
 ```python
 objects = btrack.dataio.import_CSV('napari_example.csv')
@@ -226,7 +226,7 @@ with btrack.BayesianTracker() as tracker:
     data, features, graph = tracker.to_napari(ndim=2)
 ```
 
-We set the configuration of the tracker using a configuration file using the `.configure_from_file()` method. An example configuration file can be found [here](https://github.com/quantumjot/BayesianTracker/blob/main/models/cell_config.json).
+We set the configuration of the tracker using a configuration file using the `.configure_from_file()` method. An example configuration file can be found [here](https://github.com/quantumjot/btrack/blob/main/models/cell_config.json).
 
 Next, the objects are linked into tracks using the `.track_interactive()` method. The `step_size` argument specifies how many steps are taken before reporting the tracking statistics. The `.optimize()` method then performs a global optimization on the dataset and creates lineage trees automatically.
 
@@ -240,7 +240,7 @@ napari.run()
 
 ![napari viewer with three layers: an image layer with cells, a points layer with detected cells and a tracks layer with the btrack results. The dimension slider under the canvas is close to the end of the stack, showing the tracks corresponding to each point colored by generation.](../assets/tutorials/tracks_btrack.png)
 
-A notebook for this example can be found in the btrack examples directory ([`napari_btrack.ipynb`](https://github.com/quantumjot/BayesianTracker/blob/caa56fa82330e4b16b5d28150f9b60ed963165c7/examples/napari_btrack.ipynb))
+A notebook for this example can be found in the btrack examples directory ([`napari_btrack.ipynb`](https://github.com/quantumjot/btrack/blob/caa56fa82330e4b16b5d28150f9b60ed963165c7/examples/napari_btrack.ipynb))
 
 ## Summary
 In this application note, we have used napari to track and visualize single cells.
@@ -253,5 +253,5 @@ References for cell tracking challenge:
 + http://dx.doi.org/10.1038/nmeth.4473
 
 For a more advanced example of visualizing cell tracking data with napari, please see the Arboretum plugin for napari:
-+ [btrack](https://github.com/quantumjot/BayesianTracker)
++ [btrack](https://github.com/quantumjot/btrack)
 + [arboretum](https://github.com/lowe-lab-ucl/arboretum)