From 3a07bb1d059c1fb7883de7decaa3ba541cf4becc Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Tue, 3 Jan 2023 15:09:55 +0100
Subject: [PATCH 01/15] Migrate server configuration and deployment guides into
 how_to sections

---
 doc/how_to/deployment/ae5.md                  |   3 +
 doc/how_to/deployment/azure.md                |  31 ++
 doc/how_to/deployment/binder.md               |  21 ++
 doc/how_to/deployment/gcp.md                  |  50 ++++
 doc/how_to/deployment/heroku.md               |  35 +++
 doc/how_to/deployment/huggingface.md          |  52 ++++
 doc/how_to/deployment/index.md                |  39 +++
 doc/how_to/index.md                           |  39 +++
 .../server/commandline.md}                    | 118 +-------
 doc/how_to/server/index.md                    |  48 ++++
 doc/how_to/server/multiple.md                 |  37 +++
 doc/how_to/server/programmatic.md             |  61 ++++
 doc/how_to/server/proxy.md                    |   3 +
 doc/how_to/server/ssh.md                      |  32 +++
 doc/how_to/server/static_files.md             |  11 +
 doc/user_guide/Server_Deployment.md           | 267 ------------------
 16 files changed, 463 insertions(+), 384 deletions(-)
 create mode 100644 doc/how_to/deployment/ae5.md
 create mode 100644 doc/how_to/deployment/azure.md
 create mode 100644 doc/how_to/deployment/binder.md
 create mode 100644 doc/how_to/deployment/gcp.md
 create mode 100644 doc/how_to/deployment/heroku.md
 create mode 100644 doc/how_to/deployment/huggingface.md
 create mode 100644 doc/how_to/deployment/index.md
 create mode 100644 doc/how_to/index.md
 rename doc/{user_guide/Server_Configuration.md => how_to/server/commandline.md} (61%)
 create mode 100644 doc/how_to/server/index.md
 create mode 100644 doc/how_to/server/multiple.md
 create mode 100644 doc/how_to/server/programmatic.md
 create mode 100644 doc/how_to/server/proxy.md
 create mode 100644 doc/how_to/server/ssh.md
 create mode 100644 doc/how_to/server/static_files.md
 delete mode 100644 doc/user_guide/Server_Deployment.md

diff --git a/doc/how_to/deployment/ae5.md b/doc/how_to/deployment/ae5.md
new file mode 100644
index 0000000000..fb89580db9
--- /dev/null
+++ b/doc/how_to/deployment/ae5.md
@@ -0,0 +1,3 @@
+# Anaconda Enterprise 5 (AE5)
+
+All live examples in the Panel documentation are served on AE5, to see further examples deployed there see [examples.pyviz.org](https://examples.pyviz.org) and for detailed instructions follow the [developer guide](https://examples.pyviz.org/make_project.html).
diff --git a/doc/how_to/deployment/azure.md b/doc/how_to/deployment/azure.md
new file mode 100644
index 0000000000..51f2ec6ff0
--- /dev/null
+++ b/doc/how_to/deployment/azure.md
@@ -0,0 +1,31 @@
+# Microsoft Azure
+
+Azure is popular choice for enterprises often in combination with an automated CI/CD pipeline via Azure DevOps. To get started you can use the [Azure Portal](portal.azure.com) to deploy your app as a Linux Web App via the web based user interface.
+
+There are a few things you need to be aware of in order to be able to start your app.
+
+Python Web Apps assumes your web app
+
+- is using `gunicorn` (like Flask or Django) or alternative is started by a `python` command. Thus
+    - You **cannot use** `panel serve app.py ...` as a *Startup Command*.
+    - You **can use** `python -m panel serve app.py ...` or `python app.py ...` as a *Startup command*.
+- is served on address 0.0.0.0 and port 8000
+
+Thus you can use
+
+```bash
+python -m panel serve app.py --address 0.0.0.0 --port 8000 --allow-websocket-origin=app-name.azurewebsites.net
+```
+
+as a *Startup command*.
+
+You might be able to use `python app.py` as a *Startup command* with `.show()` or `panel.serve` inside your `app.py` file, if you can configure the `address`, `port` and `allow-websocket-origin` in the app.py file or via environment variables.
+
+You also need to configure your app service **general settings** to
+
+- allow `Web sockets` and
+- be `Always on`
+
+<img src="../_static/azure_deployment.png" style="width:67%"></img>
+
+If you would like to setup **automated CI/ CD** via Azure DevOps, Azure Pipelines and Docker to a Web App for Containers, you can find a good starting point in the [devops Folder](https://github.com/MarcSkovMadsen/awesome-panel/tree/master/devops) of [awesome-panel.org](https://awesome-panel.org).
diff --git a/doc/how_to/deployment/binder.md b/doc/how_to/deployment/binder.md
new file mode 100644
index 0000000000..ff34361c92
--- /dev/null
+++ b/doc/how_to/deployment/binder.md
@@ -0,0 +1,21 @@
+# MyBinder
+
+Binder allows you to create custom computing environments that can be shared and used by many remote users. MyBinder is a public, free hosting option, with limited compute and memory resources, which will allow you to deploy your simple app quickly and easily.
+
+Here we will take you through the configuration to quickly set up a GitHub repository with notebooks containing Panel apps for deployment on MyBinder.org. As an example refer to the [Clifford demo repository](https://github.com/pyviz-demos/clifford).
+
+1. Create a GitHub repository and add the notebook or script you want to serve (in the example repository this is the clifford.ipynb file)
+
+2. Add an ``environment.yml`` which declares a conda environment with the dependencies required to run the app (refer to the [conda documentation](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#creating-an-environment-file-manually) to see how to declare your dependencies). Add `jupyter_panel_proxy` as a dependency by adding either `conda-forge` or `pyviz` to the channel list:
+
+```
+channels:
+- pyviz
+
+packages:
+- jupyter-panel-proxy
+```
+
+3. Go to mybinder.org, enter the URL of your GitHub repository and hit ``Launch``
+
+4. mybinder.org will give you a link to the deployment, e.g. for the example app it is https://mybinder.org/v2/gh/panel-demos/clifford-interact/master. To visit the app simply append ``?urlpath=/panel/clifford`` where you should replace clifford with the name of the notebook or script you are serving.
diff --git a/doc/how_to/deployment/gcp.md b/doc/how_to/deployment/gcp.md
new file mode 100644
index 0000000000..169a29be74
--- /dev/null
+++ b/doc/how_to/deployment/gcp.md
@@ -0,0 +1,50 @@
+# Google Cloud Platform (GCP)
+
+First, you need to set up your Google cloud account following the [Cloud Run documentation](https://cloud.google.com/run/docs/quickstarts/build-and-deploy/python) or the [App Engine documentation](https://cloud.google.com/appengine/docs/standard/python3/quickstart) depending on whether you would like to deploy your Panel app to Cloud Run or App Engine.
+
+Next, you will need three files:
+1. app.py: This is the Python file that creates the Panel App.
+
+2. requirements.txt: This file lists all the package dependencies of our Panel app. Here is an example for requirements.txt:
+
+```
+panel
+bokeh
+hvplot
+```
+3. app.yml (for App Engine) or Dockerfile (for Cloud Run)
+
+Here is an example for app.yml (if you would like to deploy to App Engine):
+```
+runtime: python
+env: flex
+entrypoint: panel serve app.py --address 0.0.0.0 --port 8080 --allow-websocket-origin="*"
+
+runtime_config:
+  python_version: 3
+```
+
+Here is an example for Dockerfile (if you would like to deploy to Cloud Run):
+```
+# Use the official lightweight Python image.
+# https://hub.docker.com/_/python
+FROM python:3.10-slim
+
+# Allow statements and log messages to immediately appear in the Knative logs
+ENV PYTHONUNBUFFERED True
+
+# Copy local code to the container image.
+ENV APP_HOME /app
+WORKDIR $APP_HOME
+COPY . ./
+
+# Install production dependencies.
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Run the web service on container startup.
+CMD panel serve app.py --address 0.0.0.0 --port 8080 --allow-websocket-origin="*"
+```
+
+Finally, to deploy a Panel app to App Engine run `gcloud app create` and `gcloud app deploy`. To deploy a Panel app to Cloud Run, run `gcloud run deploy`.
+
+For detailed information and steps, check out this [example](https://towardsdatascience.com/deploy-a-python-visualization-panel-app-to-google-cloud-cafe558fe787?sk=98a75bd79e98cba241cc6711e6fc5be5) on how to deploy a Panel app to App Engine and this [example](https://towardsdatascience.com/deploy-a-python-visualization-panel-app-to-google-cloud-ii-416e487b44eb?sk=aac35055957ba95641a6947bbb436410) on how to deploy a Panel app to Cloud Run.
diff --git a/doc/how_to/deployment/heroku.md b/doc/how_to/deployment/heroku.md
new file mode 100644
index 0000000000..5638ea0bdf
--- /dev/null
+++ b/doc/how_to/deployment/heroku.md
@@ -0,0 +1,35 @@
+# Heroku
+
+Heroku makes deployment of arbitrary apps including Panel apps and dashboards very easy and provides a free tier to get you started. This makes it a great starting point for users not too familiar with web development and deployment.
+
+To get started working with Heroku [signup](https://signup.heroku.com) for a free account and [download and install the CLI](https://devcenter.heroku.com/articles/getting-started-with-python#set-up). Once you are set up follow the instructions to log into the CLI.
+
+1. Create a new Git repo (or to follow along clone the [minimal-heroku-demo](https://github.com/pyviz-demos/minimal-heroku-demo) GitHub repo)
+
+2. Add a Jupyter notebook or Python script which declares a Panel app or dashboard to the repository.
+
+3. Define a requirements.txt containing all the requirements for your app (including Panel itself). For the sample app the requirements are as minimal as:
+
+```
+panel
+hvplot
+scikit-learn
+```
+
+3. Define a `Procfile` which declares the command Heroku should run to serve the app. In the sample app the following command serves the `iris_kmeans.ipynb` example. The websocket origin should match the name of the app on Heroku ``app-name.herokuapp.com`` which you will declare in the next step:
+
+```
+web: panel serve --address="0.0.0.0" --port=$PORT iris_kmeans.ipynb --allow-websocket-origin=app-name.herokuapp.com
+```
+
+4. Create a Heroku app using the CLI ensuring that the name matches the URL we declared in the previous step:
+
+```
+heroku create app-name
+```
+
+5. Push the app to heroku and wait until it is deployed.
+
+6. Visit the app at app-name.herokuapp.com
+
+Once you have deployed the app you might find that if your app is visited by more than one user at a time it will become unresponsive. In this case you can use the Heroku CLI [to scale your deployment](https://devcenter.heroku.com/articles/getting-started-with-python#scale-the-app).
diff --git a/doc/how_to/deployment/huggingface.md b/doc/how_to/deployment/huggingface.md
new file mode 100644
index 0000000000..f9555f0153
--- /dev/null
+++ b/doc/how_to/deployment/huggingface.md
@@ -0,0 +1,52 @@
+# Hugging Face
+
+The guides below assumes you have already signed up and logged into your account at [huggingface.co](https://huggingface.co/).
+
+## Duplicate an existing space
+
+The easiest way to get started is to  [search](https://huggingface.co/spaces), find and duplicate an existing space. A simple space to duplicate is
+[MarcSkovMadsen/awesome-panel](https://huggingface.co/spaces/MarcSkovMadsen/awesome-panel).
+
+- Open the space [MarcSkovMadsen/awesome-panel](https://huggingface.co/spaces/MarcSkovMadsen/awesome-panel).
+- Click the 3 dots and select *Duplicate this Space*.
+
+<img src="../../_static/hugging-face-duplicate.png" style="width:67%"></img>
+
+- Follow the instructions to finish the duplication.
+
+Once you have finalized the duplication you will need to take a look at the `app.py` file in the new space to figure out what to replace.
+
+<img src="../../_static/hugging-face-app-py.png" style="width:67%"></img>
+
+## Creating a new space from scratch
+
+You can deploy Panel to Hugging Face Spaces as a [*Custom Python Space*](https://huggingface.co/docs/hub/spaces-sdks-python). For a general introduction to Hugging Face Spaces see the [Spaces Overview](https://huggingface.co/docs/hub/spaces-overview).
+
+Go to [Spaces](https://huggingface.co/spaces) and click the "Create New Space" button.
+
+<img src="../../_static/hugging-face-create-new-space.png" style="width:67%"></img>
+
+Fill out the form. Make sure to select the *Gradio Space SDK*.
+
+<img src="../../_static/hugging-face-create-spaces-form.png" style="width:67%"></img>
+
+A Gradio space will serve your app via the commmand `python app.py`. I.e. you cannot run `panel serve app.py ...`.
+
+To work around this your `app.py` will need to either
+
+- Use `subprocess` to run `panel serve ...` or
+- Use `pn.serve` to serve one or more functions.
+
+The app also needs to run on a port given by the `PORT` environment variable.
+
+Check out the example repository [MarcSkovMadsen/awesome-panel](https://huggingface.co/spaces/MarcSkovMadsen/awesome-panel/tree/main) for inspiration.
+
+## Git clone
+
+Optionally you can git clone your repository using
+
+```bash
+git clone https://huggingface.co/spaces/NAME-OF-USER/NAME-OF-SPACE
+```
+
+<img src="../../_static/hugging-face-git-clone.png" style="width:67%"></img>
diff --git a/doc/how_to/deployment/index.md b/doc/how_to/deployment/index.md
new file mode 100644
index 0000000000..f6e7aa2a1b
--- /dev/null
+++ b/doc/how_to/deployment/index.md
@@ -0,0 +1,39 @@
+# Deploying Panel Applications
+
+Panel is built on top of Bokeh, which provides a powerful [Tornado](https://www.tornadoweb.org/en/stable/) based web-server to communicate between Python and the browser. The bokeh server makes it possible to share the app or dashboard you have built locally, your own web server or using any of the numerous cloud providers. In the deployment guides we will go through the details of deploying an app on a local system or cloud provider step-by-step.
+
+For guides on running and configuring a Panel server see the [server how-to guides](../server/index).
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} Azure
+:link: azure
+:link-type: doc
+:::
+
+:::{grid-item-card} Binder
+:link: binder
+:link-type: doc
+:::
+
+:::{grid-item-card} Google Cloud
+:link: gcp
+:link-type: doc
+:::
+
+:::{grid-item-card} Heroku
+:link: heroku
+:link-type: doc
+:::
+
+:::{grid-item-card} Hugging Face
+:link: huggingface
+:link-type: doc
+:::
+
+::::
+
+#### Other Cloud Providers
+
+Panel can be used with just about any cloud provider that can launch a Python process, including Amazon Web Services (AWS) and DigitalOcean. The Panel developers will add documentation for these services as they encounter them in their own work, but we would greatly appreciate step-by-step instructions from users working on each of these systems.
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
new file mode 100644
index 0000000000..9916ce9ffb
--- /dev/null
+++ b/doc/how_to/index.md
@@ -0,0 +1,39 @@
+# How-to Guide
+
+The Panel's How to Guides provide step by step recipes for solving essential problems and tasks. They are more advanced than the Getting Started material and assume some knowledge of how Panel works.
+
+## Running and Configuring a Panel Server
+
+## Deployment
+
+The deployment guides provide step-by-step instructions on deploying Panel applications to various cloud providers.
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} Azure
+:link: how_to/azure
+:link-type: doc
+:::
+
+:::{grid-item-card} Binder
+:link: how_to/binder
+:link-type: doc
+:::
+
+:::{grid-item-card} Google Cloud
+:link: how_to/gcp
+:link-type: doc
+:::
+
+:::{grid-item-card} Heroku
+:link: how_to/heroku
+:link-type: doc
+:::
+
+:::{grid-item-card} Hugging Face
+:link: how_to/huggingface
+:link-type: doc
+:::
+
+::::
diff --git a/doc/user_guide/Server_Configuration.md b/doc/how_to/server/commandline.md
similarity index 61%
rename from doc/user_guide/Server_Configuration.md
rename to doc/how_to/server/commandline.md
index 0545871f5d..c166eb34da 100644
--- a/doc/user_guide/Server_Configuration.md
+++ b/doc/how_to/server/commandline.md
@@ -1,8 +1,4 @@
-# Server Configuration
-
-The Panel server can be launched either from the commandline (using `panel serve`) or programmatically (using `panel.serve()`). In this guide we will discover how to run and configure server instances using these two options.
-
-## Launching a server on the commandline
+# Launching a server on the commandline
 
 Once the app is ready for deployment it can be served using the Bokeh server.  For a detailed breakdown of the design and functionality of Bokeh server, see the [Bokeh documentation](https://bokeh.pydata.org/en/latest/docs/user_guide/server.html). The most important thing to know is that Panel (and Bokeh) provide a CLI command to serve a Python script, app directory, or Jupyter notebook containing a Bokeh or Panel app. To launch a server using the CLI, simply run:
 
@@ -143,115 +139,3 @@ The ``panel serve`` command has the following options:
 To turn a notebook into a deployable app simply append ``.servable()`` to one or more Panel objects, which will add the app to Bokeh's ``curdoc``, ensuring it can be discovered by Bokeh server on deployment. In this way it is trivial to build dashboards that can be used interactively in a notebook and then seamlessly deployed on Bokeh server.
 
 When called on a notebook, `panel serve` first converts it to a python script using [`nbconvert.PythonExporter()`](https://nbconvert.readthedocs.io/en/stable/api/exporters.html), albeit with [IPython magics](https://ipython.readthedocs.io/en/stable/interactive/magics.html) stripped out. This means that non-code cells, such as raw cells, are entirely handled by `nbconvert` and [may modify the served app](https://nbsphinx.readthedocs.io/en/latest/raw-cells.html).
-
-## Launching a server dynamically
-
-The CLI `panel serve` command described below is usually the best approach for deploying applications. However when working on the REPL or embedding a Panel/Bokeh server in another application it is sometimes useful to dynamically launch a server, either using the `.show` method or using the `pn.serve` function.
-
-### Previewing an application
-
-Working from the command line will not automatically display rich representations inline as in a notebook, but you can still interact with your Panel components if you start a Bokeh server instance and open a separate browser window using the ``show`` method. The method has the following arguments:
-
-    port: int (optional)
-       Allows specifying a specific port (default=0 chooses an arbitrary open port)
-    websocket_origin: str or list(str) (optional)
-       A list of hosts that can connect to the websocket.
-       This is typically required when embedding a server app in
-       an external-facing web site.
-       If None, "localhost" is used.
-    threaded: boolean (optional, default=False)
-       Whether to launch the Server on a separate thread, allowing
-       interactive use.
-    title : str
-       A string title to give the Document (if served as an app)
-    **kwargs : dict
-       Additional keyword arguments passed to the bokeh.server.server.Server instance.
-
-To work with an app completely interactively you can set ``threaded=True`` which will launch the server on a separate thread and let you interactively play with the app.
-
-<img src='https://assets.holoviews.org/panel/gifs/commandline_show.gif'></img>
-
-The ``.show`` call will return either a Bokeh server instance (if ``threaded=False``) or a ``StoppableThread`` instance (if ``threaded=True``) which both provide a ``stop`` method to stop the server instance.
-
-### Serving multiple apps
-
-If you want to serve more than one app on a single server you can use the ``pn.serve`` function. By supplying a dictionary where the keys represent the URL slugs and the values must be either Panel objects or functions returning Panel objects you can easily launch a server with a number of apps, e.g.:
-
-```python
-import panel as pn
-pn.serve({
-    'markdown': '# This is a Panel app',
-    'json': pn.pane.JSON({'abc': 123})
-})
-```
-
-Note that when you serve an object directly all sessions will share the same state, i.e. the parameters of all components will be synced across sessions such that the change in a widget by one user will affect all other users. Therefore you will usually want to wrap your app in a function, ensuring that each user gets a new instance of the application:
-
-```python
-
-def markdown_app():
-    return '# This is a Panel app'
-
-def json_app():
-    return pn.pane.JSON({'abc': 123})
-
-pn.serve({
-    'markdown': markdown_app,
-    'json': json_app
-})
-```
-
-You can customize the HTML title of each application by supplying a dictionary where the keys represent the URL slugs and the values represent the titles, e.g.:
-
-```python
-pn.serve({
-    'markdown': '# This is a Panel app',
-    'json': pn.pane.JSON({'abc': 123})
-}, title={'markdown': 'A Markdown App', 'json': 'A JSON App'}
-)
-```
-
-The ``pn.serve`` accepts a number of arguments:
-
-    panel: Viewable, function or {str: Viewable or function}
-      A Panel object, a function returning a Panel object or a
-      dictionary mapping from the URL slug to either.
-    port: int (optional, default=0)
-      Allows specifying a specific port
-    address: str
-      The address the server should listen on for HTTP requests.
-    websocket_origin: str or list(str) (optional)
-      A list of hosts that can connect to the websocket.
-
-      This is typically required when embedding a server app in
-      an external web site.
-
-      If None, "localhost" is used.
-    loop: tornado.ioloop.IOLoop (optional, default=IOLoop.current())
-      The tornado IOLoop to run the Server on
-    show: boolean (optional, default=False)
-      Whether to open the server in a new browser tab on start
-    start: boolean(optional, default=False)
-      Whether to start the Server
-    title: str or {str: str} (optional, default=None)
-      An HTML title for the application or a dictionary mapping
-      from the URL slug to a customized title
-    verbose: boolean (optional, default=True)
-      Whether to print the address and port
-    location: boolean or panel.io.location.Location
-      Whether to create a Location component to observe and
-      set the URL location.
-    kwargs: dict
-      Additional keyword arguments to pass to Server instance
-
-## Static file hosting
-
-Whether you're launching your application using `panel serve` from the commandline or using `pn.serve` in a script you can also serve static files. When using `panel serve` you can use the `--static-dirs` argument to specify a list of static directories to serve along with their routes, e.g.:
-
-    panel serve some_script.py --static-dirs assets=./assets
-
-This will serve the `./assets` directory on the servers `/assets` route. Note however that the `/static` route is reserved internally by Panel.
-
-Similarly when using `pn.serve` or `panel_obj.show` the static routes may be defined as a dictionary, e.g. the equivalent to the example would be:
-
-    pn.serve(panel_obj, static_dirs={'assets': './assets'})
diff --git a/doc/how_to/server/index.md b/doc/how_to/server/index.md
new file mode 100644
index 0000000000..269af84ec7
--- /dev/null
+++ b/doc/how_to/server/index.md
@@ -0,0 +1,48 @@
+# Running and configuring a Panel server
+
+The Panel server can be launched either from the commandline (using `panel serve`) or programmatically (using `panel.serve()`). In this guide we will discover how to run and configure server instances using these two options.
+
+## The server
+
+The Bokeh server is built on Tornado, which handles all of the communication between the browser and the backend. Whenever a user accesses the app or dashboard in a browser a new session is created which executes the app code and creates a new ``Document`` containing the models served to the browser where they are rendered by BokehJS.
+
+<div style="margin-left: auto; margin-right: auto; display: block">
+<img src="https://bokeh.pydata.org/en/latest/_images/bokeh_serve.svg"></img>
+</div>
+
+If you do not want to maintain your own web server and/or set up complex reverse proxies various cloud providers make it relatively simple to quickly deploy arbitrary apps on their system. See the [deployment how-to guides](../deployment/index) for more details.
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} Launch Panel server from the commandline
+:link: commandline
+:link-type: doc
+:::
+
+:::{grid-item-card} Launch Panel server programmatically
+:link: programmatic
+:link-type: doc
+:::
+
+:::{grid-item-card} Serving multiple applications
+:link: multiple
+:link-type: doc
+:::
+
+:::{grid-item-card} Accessing a deployment over SSH
+:link: ssh
+:link-type: doc
+:::
+
+:::{grid-item-card} Setting up a (reverse) proxy
+:link: proxy
+:link-type: doc
+:::
+
+:::{grid-item-card} Serving static files
+:link: static_files
+:link-type: doc
+:::
+
+::::
diff --git a/doc/how_to/server/multiple.md b/doc/how_to/server/multiple.md
new file mode 100644
index 0000000000..6e87ba109c
--- /dev/null
+++ b/doc/how_to/server/multiple.md
@@ -0,0 +1,37 @@
+# Serving multiple applications
+
+If you want to serve more than one app on a single server you can use the ``pn.serve`` function. By supplying a dictionary where the keys represent the URL slugs and the values must be either Panel objects or functions returning Panel objects you can easily launch a server with a number of apps, e.g.:
+
+```python
+import panel as pn
+pn.serve({
+    'markdown': '# This is a Panel app',
+    'json': pn.pane.JSON({'abc': 123})
+})
+```
+
+Note that when you serve an object directly all sessions will share the same state, i.e. the parameters of all components will be synced across sessions such that the change in a widget by one user will affect all other users. Therefore you will usually want to wrap your app in a function, ensuring that each user gets a new instance of the application:
+
+```python
+
+def markdown_app():
+    return '# This is a Panel app'
+
+def json_app():
+    return pn.pane.JSON({'abc': 123})
+
+pn.serve({
+    'markdown': markdown_app,
+    'json': json_app
+})
+```
+
+You can customize the HTML title of each application by supplying a dictionary where the keys represent the URL slugs and the values represent the titles, e.g.:
+
+```python
+pn.serve({
+    'markdown': '# This is a Panel app',
+    'json': pn.pane.JSON({'abc': 123})
+}, title={'markdown': 'A Markdown App', 'json': 'A JSON App'}
+)
+```
diff --git a/doc/how_to/server/programmatic.md b/doc/how_to/server/programmatic.md
new file mode 100644
index 0000000000..2b9a32e22e
--- /dev/null
+++ b/doc/how_to/server/programmatic.md
@@ -0,0 +1,61 @@
+# Launching a server dynamically
+
+The CLI `panel serve` command described below is usually the best approach for deploying applications. However when working on the REPL or embedding a Panel/Bokeh server in another application it is sometimes useful to dynamically launch a server, either using the `.show` method or using the `pn.serve` function.
+
+## Previewing an application
+
+Working from the command line will not automatically display rich representations inline as in a notebook, but you can still interact with your Panel components if you start a Bokeh server instance and open a separate browser window using the ``show`` method. The method has the following arguments:
+
+    port: int (optional)
+       Allows specifying a specific port (default=0 chooses an arbitrary open port)
+    websocket_origin: str or list(str) (optional)
+       A list of hosts that can connect to the websocket.
+       This is typically required when embedding a server app in
+       an external-facing web site.
+       If None, "localhost" is used.
+    threaded: boolean (optional, default=False)
+       Whether to launch the Server on a separate thread, allowing
+       interactive use.
+    title : str
+       A string title to give the Document (if served as an app)
+    **kwargs : dict
+       Additional keyword arguments passed to the bokeh.server.server.Server instance.
+
+To work with an app completely interactively you can set ``threaded=True`` which will launch the server on a separate thread and let you interactively play with the app.
+
+<img src='https://assets.holoviews.org/panel/gifs/commandline_show.gif'></img>
+
+The ``.show`` call will return either a Bokeh server instance (if ``threaded=False``) or a ``StoppableThread`` instance (if ``threaded=True``) which both provide a ``stop`` method to stop the server instance.
+
+The ``pn.serve`` accepts a number of arguments:
+
+    panel: Viewable, function or {str: Viewable or function}
+      A Panel object, a function returning a Panel object or a
+      dictionary mapping from the URL slug to either.
+    port: int (optional, default=0)
+      Allows specifying a specific port
+    address: str
+      The address the server should listen on for HTTP requests.
+    websocket_origin: str or list(str) (optional)
+      A list of hosts that can connect to the websocket.
+
+      This is typically required when embedding a server app in
+      an external web site.
+
+      If None, "localhost" is used.
+    loop: tornado.ioloop.IOLoop (optional, default=IOLoop.current())
+      The tornado IOLoop to run the Server on
+    show: boolean (optional, default=False)
+      Whether to open the server in a new browser tab on start
+    start: boolean(optional, default=False)
+      Whether to start the Server
+    title: str or {str: str} (optional, default=None)
+      An HTML title for the application or a dictionary mapping
+      from the URL slug to a customized title
+    verbose: boolean (optional, default=True)
+      Whether to print the address and port
+    location: boolean or panel.io.location.Location
+      Whether to create a Location component to observe and
+      set the URL location.
+    kwargs: dict
+      Additional keyword arguments to pass to Server instance
diff --git a/doc/how_to/server/proxy.md b/doc/how_to/server/proxy.md
new file mode 100644
index 0000000000..6e265ec3d5
--- /dev/null
+++ b/doc/how_to/server/proxy.md
@@ -0,0 +1,3 @@
+# Configurign a reverse proxy
+
+If the goal is to serve an web application to the general Internet, it is often desirable to host the application on an internal network, and proxy connections to it through some dedicated HTTP server. For some basic configurations to set up a Bokeh server behind some common reverse proxies, including Nginx and Apache, refer to the [Bokeh documentation](https://bokeh.pydata.org/en/latest/docs/user_guide/server.html#basic-reverse-proxy-setup).
diff --git a/doc/how_to/server/ssh.md b/doc/how_to/server/ssh.md
new file mode 100644
index 0000000000..ff8997490f
--- /dev/null
+++ b/doc/how_to/server/ssh.md
@@ -0,0 +1,32 @@
+# Connect to a remote server via SSH
+
+In some scenarios a standalone bokeh server may be running on remote host. In such cases, SSH can be used to “tunnel” to the server. In the simplest scenario, the Bokeh server will run on one host and will be accessed from another location, e.g., a laptop, with no intermediary machines.
+
+Run the server as usual on the remote host:
+
+Next, issue the following command on the local machine to establish an SSH tunnel to the remote host:
+
+```
+ssh -NfL localhost:5006:localhost:5006 user@remote.host
+```
+
+Replace user with your username on the remote host and remote.host with the hostname/IP address of the system hosting the Bokeh server. You may be prompted for login credentials for the remote system. After the connection is set up you will be able to navigate to localhost:5006 as though the Bokeh server were running on the local machine.
+
+The second, slightly more complicated case occurs when there is a gateway between the server and the local machine. In that situation a reverse tunnel must be established from the server to the gateway. Additionally the tunnel from the local machine will also point to the gateway.
+
+Issue the following commands on the remote host where the Bokeh server will run:
+
+```
+nohup bokeh server &
+ssh -NfR 5006:localhost:5006 user@gateway.host
+```
+
+Replace user with your username on the gateway and gateway.host with the hostname/IP address of the gateway. You may be prompted for login credentials for the gateway.
+
+Now set up the other half of the tunnel, from the local machine to the gateway. On the local machine:
+
+```
+ssh -NfL localhost:5006:localhost:5006 user@gateway.host
+```
+
+Again, replace user with your username on the gateway and gateway.host with the hostname/IP address of the gateway. You should now be able to access the Bokeh server from the local machine by navigating to localhost:5006 on the local machine, as if the Bokeh server were running on the local machine. You can even set up client connections from a Jupyter notebook running on the local machine.
diff --git a/doc/how_to/server/static_files.md b/doc/how_to/server/static_files.md
new file mode 100644
index 0000000000..c3d4f081f3
--- /dev/null
+++ b/doc/how_to/server/static_files.md
@@ -0,0 +1,11 @@
+# Serving static files
+
+Whether you're launching your application using `panel serve` from the commandline or using `pn.serve` in a script you can also serve static files. When using `panel serve` you can use the `--static-dirs` argument to specify a list of static directories to serve along with their routes, e.g.:
+
+    panel serve some_script.py --static-dirs assets=./assets
+
+This will serve the `./assets` directory on the servers `/assets` route. Note however that the `/static` route is reserved internally by Panel.
+
+Similarly when using `pn.serve` or `panel_obj.show` the static routes may be defined as a dictionary, e.g. the equivalent to the example would be:
+
+    pn.serve(panel_obj, static_dirs={'assets': './assets'})
diff --git a/doc/user_guide/Server_Deployment.md b/doc/user_guide/Server_Deployment.md
deleted file mode 100644
index 39b544312e..0000000000
--- a/doc/user_guide/Server_Deployment.md
+++ /dev/null
@@ -1,267 +0,0 @@
-# Server Deployment
-
-Panel is built on top of Bokeh, which provides a powerful [Tornado](https://www.tornadoweb.org/en/stable/) based web-server to communicate between Python and the browser. The bokeh server makes it possible to share the app or dashboard you have built locally, your own web server or using any of the numerous cloud providers. In this guide we will go through the details of deploying an app on a local system or cloud provider step by step.
-
-## The server
-
-The Bokeh server is built on Tornado, which handles all of the communication between the browser and the backend. Whenever a user accesses the app or dashboard in a browser a new session is created which executes the app code and creates a new ``Document`` containing the models served to the browser where they are rendered by BokehJS.
-
-<div style="margin-left: auto; margin-right: auto; display: block">
-<img src="https://bokeh.pydata.org/en/latest/_images/bokeh_serve.svg"></img>
-</div>
-
-### Accessing request arguments
-
-When a user accesses the Panel application via the browser they can optionally provide additional arguments in the URL. For example the query string ``?N=10`` will result in the following argument will be available on ``pn.state.session_args``: ``{'N': [b'10']}``. Such arguments may be used to customize the application.
-
-## Deployment
-
-As was covered in [Server Configuration](Server_Configuration.md) guide a Panel app, either in a notebook or a Python script, can be annotated with `.servable()` and then launched from the commandline using ``panel serve``. This launches a Tornado server on a specific port (defaulting to 5006) which you can access locally at ``https://localhost:{PORT}``. This is a good option for simple deployments on a local network.
-
-However many deployment scenarios have additional requirements around authentication, scaling, and uptime.
-
-### SSH
-
-In some scenarios a standalone bokeh server may be running on remote host. In such cases, SSH can be used to “tunnel” to the server. In the simplest scenario, the Bokeh server will run on one host and will be accessed from another location, e.g., a laptop, with no intermediary machines.
-
-Run the server as usual on the remote host:
-
-Next, issue the following command on the local machine to establish an SSH tunnel to the remote host:
-
-```
-ssh -NfL localhost:5006:localhost:5006 user@remote.host
-```
-
-Replace user with your username on the remote host and remote.host with the hostname/IP address of the system hosting the Bokeh server. You may be prompted for login credentials for the remote system. After the connection is set up you will be able to navigate to localhost:5006 as though the Bokeh server were running on the local machine.
-
-The second, slightly more complicated case occurs when there is a gateway between the server and the local machine. In that situation a reverse tunnel must be established from the server to the gateway. Additionally the tunnel from the local machine will also point to the gateway.
-
-Issue the following commands on the remote host where the Bokeh server will run:
-
-```
-nohup bokeh server &
-ssh -NfR 5006:localhost:5006 user@gateway.host
-```
-
-Replace user with your username on the gateway and gateway.host with the hostname/IP address of the gateway. You may be prompted for login credentials for the gateway.
-
-Now set up the other half of the tunnel, from the local machine to the gateway. On the local machine:
-
-```
-ssh -NfL localhost:5006:localhost:5006 user@gateway.host
-```
-
-Again, replace user with your username on the gateway and gateway.host with the hostname/IP address of the gateway. You should now be able to access the Bokeh server from the local machine by navigating to localhost:5006 on the local machine, as if the Bokeh server were running on the local machine. You can even set up client connections from a Jupyter notebook running on the local machine.
-
-### Reverse proxy
-
-If the goal is to serve an web application to the general Internet, it is often desirable to host the application on an internal network, and proxy connections to it through some dedicated HTTP server. For some basic configurations to set up a Bokeh server behind some common reverse proxies, including Nginx and Apache, refer to the [Bokeh documentation](https://bokeh.pydata.org/en/latest/docs/user_guide/server.html#basic-reverse-proxy-setup).
-
-### Cloud Deployments
-
-If you do not want to maintain your own web server and/or set up complex reverse proxies various cloud providers make it relatively simple to quickly deploy arbitrary apps on their system. In this section we will go through step-by-step to set up deployments on some of these providers.
-
-#### MyBinder
-
-Binder allows you to create custom computing environments that can be shared and used by many remote users. MyBinder is a public, free hosting option, with limited compute and memory resources, which will allow you to deploy your simple app quickly and easily.
-
-Here we will take you through the configuration to quickly set up a GitHub repository with notebooks containing Panel apps for deployment on MyBinder.org. As an example refer to the [Clifford demo repository](https://github.com/pyviz-demos/clifford).
-
-1. Create a GitHub repository and add the notebook or script you want to serve (in the example repository this is the clifford.ipynb file)
-
-2. Add an ``environment.yml`` which declares a conda environment with the dependencies required to run the app (refer to the [conda documentation](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#creating-an-environment-file-manually) to see how to declare your dependencies). Add `jupyter_panel_proxy` as a dependency by adding either `conda-forge` or `pyviz` to the channel list:
-
-
-```
-channels:
-- pyviz
-
-packages:
-- jupyter-panel-proxy
-```
-
-3. Go to mybinder.org, enter the URL of your GitHub repository and hit ``Launch``
-
-4. mybinder.org will give you a link to the deployment, e.g. for the example app it is https://mybinder.org/v2/gh/panel-demos/clifford-interact/main. To visit the app simply append ``?urlpath=/panel/clifford`` where you should replace clifford with the name of the notebook or script you are serving.
-
-
-#### Heroku
-
-Heroku makes deployment of arbitrary apps including Panel apps and dashboards very easy and provides a free tier to get you started. This makes it a great starting point for users not too familiar with web development and deployment.
-
-To get started working with Heroku [signup](https://signup.heroku.com) for a free account and [download and install the CLI](https://devcenter.heroku.com/articles/getting-started-with-python#set-up). Once you are set up follow the instructions to log into the CLI.
-
-1. Create a new Git repo (or to follow along clone the [minimal-heroku-demo](https://github.com/pyviz-demos/minimal-heroku-demo) GitHub repo)
-
-2. Add a Jupyter notebook or Python script which declares a Panel app or dashboard to the repository.
-
-3. Define a requirements.txt containing all the requirements for your app (including Panel itself). For the sample app the requirements are as minimal as:
-
-```
-panel
-hvplot
-scikit-learn
-```
-
-3. Define a `Procfile` which declares the command Heroku should run to serve the app. In the sample app the following command serves the `iris_kmeans.ipynb` example. The websocket origin should match the name of the app on Heroku ``app-name.herokuapp.com`` which you will declare in the next step:
-
-```
-web: panel serve --address="0.0.0.0" --port=$PORT iris_kmeans.ipynb --allow-websocket-origin=app-name.herokuapp.com
-```
-
-4. Create a Heroku app using the CLI ensuring that the name matches the URL we declared in the previous step:
-
-```
-heroku create app-name
-```
-
-5. Push the app to heroku and wait until it is deployed.
-
-6. Visit the app at app-name.herokuapp.com
-
-Once you have deployed the app you might find that if your app is visited by more than one user at a time it will become unresponsive. In this case you can use the Heroku CLI [to scale your deployment](https://devcenter.heroku.com/articles/getting-started-with-python#scale-the-app).
-
-#### Anaconda Enterprise 5 (AE5)
-
-All live examples in the Panel documentation are served on AE5, to see further examples deployed there see [examples.pyviz.org](https://examples.pyviz.org) and for detailed instructions follow the [developer guide](https://examples.pyviz.org/make_project.html).
-
-#### Microsoft Azure
-
-Azure is popular choice for enterprises often in combination with an automated CI/CD pipeline via Azure DevOps. To get started you can use the [Azure Portal](portal.azure.com) to deploy your app as a Linux Web App via the web based user interface.
-
-There are a few things you need to be aware of in order to be able to start your app.
-
-Python Web Apps assumes your web app
-
-- is using `gunicorn` (like Flask or Django) or alternative is started by a `python` command. Thus
-    - You **cannot use** `panel serve app.py ...` as a *Startup Command*.
-    - You **can use** `python -m panel serve app.py ...` or `python app.py ...` as a *Startup command*.
-- is served on address 0.0.0.0 and port 8000
-
-Thus you can use
-
-```bash
-python -m panel serve app.py --address 0.0.0.0 --port 8000 --allow-websocket-origin=app-name.azurewebsites.net
-```
-
-as a *Startup command*.
-
-You might be able to use `python app.py` as a *Startup command* with `.show()` or `panel.serve` inside your `app.py` file, if you can configure the `address`, `port` and `allow-websocket-origin` in the app.py file or via environment variables.
-
-You also need to configure your app service **general settings** to
-
-- allow `Web sockets` and
-- be `Always on`
-
-<img src="../_static/azure_deployment.png" style="width:67%"></img>
-
-If you would like to setup **automated CI/ CD** via Azure DevOps, Azure Pipelines and Docker to a Web App for Containers, you can find a good starting point in the [devops Folder](https://github.com/MarcSkovMadsen/awesome-panel/tree/master/devops) of [awesome-panel.org](https://awesome-panel.org).
-
-
-#### Google Cloud Platform (GCP)
-
-First, you need to set up your Google cloud account following the [Cloud Run documentation](https://cloud.google.com/run/docs/quickstarts/build-and-deploy/python) or the [App Engine documentation](https://cloud.google.com/appengine/docs/standard/python3/quickstart) depending on whether you would like to deploy your Panel app to Cloud Run or App Engine.
-
-Next, you will need three files:
-1. app.py: This is the Python file that creates the Panel App.
-
-2. requirements.txt: This file lists all the package dependencies of our Panel app. Here is an example for requirements.txt:
-
-```
-panel
-bokeh
-hvplot
-```
-3. app.yml (for App Engine) or Dockerfile (for Cloud Run)
-
-Here is an example for app.yml (if you would like to deploy to App Engine):
-```
-runtime: python
-env: flex
-entrypoint: panel serve app.py --address 0.0.0.0 --port 8080 --allow-websocket-origin="*"
-
-runtime_config:
-  python_version: 3
-```
-
-Here is an example for Dockerfile (if you would like to deploy to Cloud Run):
-```
-# Use the official lightweight Python image.
-# https://hub.docker.com/_/python
-FROM python:3.10-slim
-
-# Allow statements and log messages to immediately appear in the Knative logs
-ENV PYTHONUNBUFFERED True
-
-# Copy local code to the container image.
-ENV APP_HOME /app
-WORKDIR $APP_HOME
-COPY . ./
-
-# Install production dependencies.
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Run the web service on container startup.
-CMD panel serve app.py --address 0.0.0.0 --port 8080 --allow-websocket-origin="*"
-```
-
-Finally, to deploy a Panel app to App Engine run `gcloud app create` and `gcloud app deploy`. To deploy a Panel app to Cloud Run, run `gcloud run deploy`.
-
-For detailed information and steps, check out this [example](https://towardsdatascience.com/deploy-a-python-visualization-panel-app-to-google-cloud-cafe558fe787?sk=98a75bd79e98cba241cc6711e6fc5be5) on how to deploy a Panel app to App Engine and this [example](https://towardsdatascience.com/deploy-a-python-visualization-panel-app-to-google-cloud-ii-416e487b44eb?sk=aac35055957ba95641a6947bbb436410) on how to deploy a Panel app to Cloud Run.
-
-#### Hugging Face
-
-The guides below assumes you have already signed up and logged into your account at [huggingface.co](https://huggingface.co/).
-
-##### Duplicate an existing space
-
-The easiest way to get started is to  [search](https://huggingface.co/spaces), find and duplicate an existing space. A simple space to duplicate is
-[MarcSkovMadsen/awesome-panel](https://huggingface.co/spaces/MarcSkovMadsen/awesome-panel).
-
-- Open the space [MarcSkovMadsen/awesome-panel](https://huggingface.co/spaces/MarcSkovMadsen/awesome-panel).
-- Click the 3 dots and select *Duplicate this Space*.
-
-<img src="../_static/hugging-face-duplicate.png" style="width:67%"></img>
-
-- Follow the instructions to finish the duplication.
-
-Once you have finalized the duplication you will need to take a look at the `app.py` file in the new space to figure out what to replace.
-
-<img src="../_static/hugging-face-app-py.png" style="width:67%"></img>
-
-##### Creating a new space from scratch
-
-You can deploy Panel to Hugging Face Spaces as a [*Custom Python Space*](https://huggingface.co/docs/hub/spaces-sdks-python). For a general introduction to Hugging Face Spaces see the [Spaces Overview](https://huggingface.co/docs/hub/spaces-overview).
-
-Go to [Spaces](https://huggingface.co/spaces) and click the "Create New Space" button.
-
-<img src="../_static/hugging-face-create-new-space.png" style="width:67%"></img>
-
-Fill out the form. Make sure to select the *Gradio Space SDK*.
-
-<img src="../_static/hugging-face-create-spaces-form.png" style="width:67%"></img>
-
-A Gradio space will serve your app via the commmand `python app.py`. I.e. you cannot run `panel serve app.py ...`.
-
-To work around this your `app.py` will need to either
-
-- Use `subprocess` to run `panel serve ...` or
-- Use `pn.serve` to serve one or more functions.
-
-The app also needs to run on a port given by the `PORT` environment variable.
-
-Check out the example repository [MarcSkovMadsen/awesome-panel](https://huggingface.co/spaces/MarcSkovMadsen/awesome-panel/tree/main) for inspiration.
-
-##### Git clone
-
-Optionally you can git clone your repository using
-
-```bash
-git clone https://huggingface.co/spaces/NAME-OF-USER/NAME-OF-SPACE
-```
-
-<img src="../_static/hugging-face-git-clone.png" style="width:67%"></img>
-
-#### Other Cloud Providers
-
-Panel can be used with just about any cloud provider that can launch a Python process, including Amazon Web Services (AWS) and DigitalOcean. The Panel developers will add documentation for these services as they encounter them in their own work, but we would greatly appreciate step-by-step instructions from users working on each of these systems.

From 32bf2ba71b81b38bc71abc1d536e1890fb9929b7 Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Tue, 3 Jan 2023 16:25:32 +0100
Subject: [PATCH 02/15] Add integrations section

---
 doc/how_to/deployment/azure.md                |  2 +-
 doc/how_to/deployment/index.md                | 14 +++++-
 doc/how_to/index.md                           | 25 ++++++++---
 .../integrations}/Django.md                   |  2 +-
 .../integrations}/FastAPI.md                  |  4 +-
 doc/how_to/integrations/flask.md              |  3 ++
 doc/how_to/integrations/index.md              | 33 ++++++++++++++
 doc/how_to/server/index.md                    | 43 +++++++++++++++----
 doc/index.md                                  |  1 +
 9 files changed, 106 insertions(+), 21 deletions(-)
 rename doc/{user_guide => how_to/integrations}/Django.md (99%)
 rename doc/{user_guide => how_to/integrations}/FastAPI.md (99%)
 create mode 100644 doc/how_to/integrations/flask.md
 create mode 100644 doc/how_to/integrations/index.md

diff --git a/doc/how_to/deployment/azure.md b/doc/how_to/deployment/azure.md
index 51f2ec6ff0..9aa6285dc9 100644
--- a/doc/how_to/deployment/azure.md
+++ b/doc/how_to/deployment/azure.md
@@ -26,6 +26,6 @@ You also need to configure your app service **general settings** to
 - allow `Web sockets` and
 - be `Always on`
 
-<img src="../_static/azure_deployment.png" style="width:67%"></img>
+<img src="../../_static/azure_deployment.png" style="width:67%"></img>
 
 If you would like to setup **automated CI/ CD** via Azure DevOps, Azure Pipelines and Docker to a Web App for Containers, you can find a good starting point in the [devops Folder](https://github.com/MarcSkovMadsen/awesome-panel/tree/master/devops) of [awesome-panel.org](https://awesome-panel.org).
diff --git a/doc/how_to/deployment/index.md b/doc/how_to/deployment/index.md
index f6e7aa2a1b..605fcf4f6a 100644
--- a/doc/how_to/deployment/index.md
+++ b/doc/how_to/deployment/index.md
@@ -4,7 +4,7 @@ Panel is built on top of Bokeh, which provides a powerful [Tornado](https://www.
 
 For guides on running and configuring a Panel server see the [server how-to guides](../server/index).
 
-::::{grid} 1 2 2 3
+::::{grid} 2 3 3 5
 :gutter: 1 1 1 2
 
 :::{grid-item-card} Azure
@@ -37,3 +37,15 @@ For guides on running and configuring a Panel server see the [server how-to guid
 #### Other Cloud Providers
 
 Panel can be used with just about any cloud provider that can launch a Python process, including Amazon Web Services (AWS) and DigitalOcean. The Panel developers will add documentation for these services as they encounter them in their own work, but we would greatly appreciate step-by-step instructions from users working on each of these systems.
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+azure
+binder
+gcp
+heroku
+huggingface
+```
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index 9916ce9ffb..f6f637b5d5 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -2,38 +2,49 @@
 
 The Panel's How to Guides provide step by step recipes for solving essential problems and tasks. They are more advanced than the Getting Started material and assume some knowledge of how Panel works.
 
-## Running and Configuring a Panel Server
+## Configuring a Panel Server
 
 ## Deployment
 
 The deployment guides provide step-by-step instructions on deploying Panel applications to various cloud providers.
 
-::::{grid} 1 2 2 3
+::::{grid} 2 3 3 5
 :gutter: 1 1 1 2
 
 :::{grid-item-card} Azure
-:link: how_to/azure
+:link: deployment/azure
 :link-type: doc
 :::
 
 :::{grid-item-card} Binder
-:link: how_to/binder
+:link: deployment/binder
 :link-type: doc
 :::
 
 :::{grid-item-card} Google Cloud
-:link: how_to/gcp
+:link: deployment/gcp
 :link-type: doc
 :::
 
 :::{grid-item-card} Heroku
-:link: how_to/heroku
+:link: deployment/heroku
 :link-type: doc
 :::
 
 :::{grid-item-card} Hugging Face
-:link: how_to/huggingface
+:link: deployment/huggingface
 :link-type: doc
 :::
 
 ::::
+
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+server/index
+integrations/index
+deployment/index
+```
\ No newline at end of file
diff --git a/doc/user_guide/Django.md b/doc/how_to/integrations/Django.md
similarity index 99%
rename from doc/user_guide/Django.md
rename to doc/how_to/integrations/Django.md
index e5d77976e3..32db02d883 100644
--- a/doc/user_guide/Django.md
+++ b/doc/how_to/integrations/Django.md
@@ -1,4 +1,4 @@
-# Django
+# Running Panel apps inside Django
 
 Panel generally runs on the Bokeh server which itself runs on Tornado. However, it is also often useful to embed a Panel app in large web application, such as a Django web server. Using Panel with Django requires a bit more work than for notebooks and Bokeh servers.
 
diff --git a/doc/user_guide/FastAPI.md b/doc/how_to/integrations/FastAPI.md
similarity index 99%
rename from doc/user_guide/FastAPI.md
rename to doc/how_to/integrations/FastAPI.md
index 89729454f7..956a491004 100644
--- a/doc/user_guide/FastAPI.md
+++ b/doc/how_to/integrations/FastAPI.md
@@ -1,4 +1,4 @@
-# FastAPI
+# Integrating Panel with FastAPI
 
 Panel generally runs on the Bokeh server which itself runs on Tornado. However, it is also often useful to embed a Panel app in large web application, such as a FastAPI web server. [FastAPI](https://fastapi.tiangolo.com/) is especially useful compared to others like Flask and Django because of it's lightning fast, lightweight framework. Using Panel with FastAPI requires a bit more work than for notebooks and Bokeh servers.
 
@@ -11,7 +11,7 @@ Before we start adding a bokeh app to our FastApi server we have to set up some
 You'll need to create a file called `examples/apps/fastApi/main.py`.
 
 In `main.py` you'll need to import the following( which should all be already available from the above conda installs):
-
+i
 ```python
 import panel as pn
 from bokeh.embed import server_document
diff --git a/doc/how_to/integrations/flask.md b/doc/how_to/integrations/flask.md
new file mode 100644
index 0000000000..3931408008
--- /dev/null
+++ b/doc/how_to/integrations/flask.md
@@ -0,0 +1,3 @@
+# Integrating Panel with Flask
+
+WIP
diff --git a/doc/how_to/integrations/index.md b/doc/how_to/integrations/index.md
new file mode 100644
index 0000000000..c82cf38a27
--- /dev/null
+++ b/doc/how_to/integrations/index.md
@@ -0,0 +1,33 @@
+# Server Integrations
+
+These guides will cover how to integrate Panel applications with various external frameworks such as Django, FastAPI and Flask.
+
+::::{grid} 2 3 3 5
+:gutter: 1 1 1 2
+
+:::{grid-item-card} Flask
+:link: flask
+:link-type: doc
+:::
+
+:::{grid-item-card} FastAPI
+:link: FastAPI
+:link-type: doc
+:::
+
+:::{grid-item-card} Django
+:link: django
+:link-type: doc
+:::
+
+::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+flask
+FastAPI
+django
+```
diff --git a/doc/how_to/server/index.md b/doc/how_to/server/index.md
index 269af84ec7..7f9e42298f 100644
--- a/doc/how_to/server/index.md
+++ b/doc/how_to/server/index.md
@@ -1,4 +1,4 @@
-# Running and configuring a Panel server
+# Configuring a Panel server
 
 The Panel server can be launched either from the commandline (using `panel serve`) or programmatically (using `panel.serve()`). In this guide we will discover how to run and configure server instances using these two options.
 
@@ -15,34 +15,59 @@ If you do not want to maintain your own web server and/or set up complex reverse
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
-:::{grid-item-card} Launch Panel server from the commandline
+:::{grid-item-card} {octicon}`terminal;2.5em;sd-mr-1` Launch from the commandline
 :link: commandline
 :link-type: doc
+
+Launch and configure a Panel application from the commandline.
 :::
 
-:::{grid-item-card} Launch Panel server programmatically
+:::{grid-item-card} {octicon}`code-square;2.5em;sd-mr-1` Launch programmatically
 :link: programmatic
 :link-type: doc
+
+Launch and configure a Panel application programmatically.
 :::
 
-:::{grid-item-card} Serving multiple applications
+:::{grid-item-card} {octicon}`stack;2.5em;sd-mr-1` Serving multiple applications
 :link: multiple
 :link-type: doc
+
+Discover how-to launch and configure multiple applications on the same server. 
 :::
 
-:::{grid-item-card} Accessing a deployment over SSH
-:link: ssh
+:::{grid-item-card} {octicon}`server;2.5em;sd-mr-1` Setting up a (reverse) proxy
+:link: proxy
 :link-type: doc
+
+Discover how-to configure a reverse proxy to scale your deployment.
 :::
 
-:::{grid-item-card} Setting up a (reverse) proxy
-:link: proxy
+:::{grid-item-card} {octicon}`chevron-right;2.5em;sd-mr-1` Access via SSH
+:link: ssh
 :link-type: doc
+
+Discover how to access a Panel deployment running remotely via SSH.
 :::
 
-:::{grid-item-card} Serving static files
+:::{grid-item-card} {octicon}`file-media;2.5em;sd-mr-1` Serving static files
 :link: static_files
 :link-type: doc
+
+Discover how to serve static files alongside your Panel application(s). 
 :::
 
 ::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+commandline
+programmatic
+multiple
+ssh
+proxy
+static_files
+```
diff --git a/doc/index.md b/doc/index.md
index dad4131513..1c73534470 100644
--- a/doc/index.md
+++ b/doc/index.md
@@ -155,6 +155,7 @@ alt: Blackstone Logo
 
 self
 getting_started/index.md
+how_to/index.md
 user_guide/index.rst
 gallery/index.rst
 reference/index.rst

From 0e744d946dc8ce6282d5b51b968ebfa992f20f5b Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Tue, 3 Jan 2023 19:31:18 +0100
Subject: [PATCH 03/15] Move more materials from user guide to how-to guide

---
 doc/conf.py                                   |   1 -
 doc/how_to/authentication/configuration.md    | 117 +++++
 doc/how_to/authentication/index.md            |  51 +++
 doc/how_to/authentication/providers.md        |  45 ++
 doc/how_to/authentication/user_info.md        |  40 ++
 doc/how_to/caching/index.md                   |  31 ++
 doc/how_to/caching/manual.md                  |  23 +
 doc/how_to/caching/memoization.md             |  45 ++
 doc/how_to/callbacks/async.md                 |  92 ++++
 doc/how_to/callbacks/index.md                 |  61 +++
 doc/how_to/callbacks/load.md                  |  31 ++
 doc/how_to/callbacks/periodic.md              |  64 +++
 doc/how_to/callbacks/schedule.md              |  32 ++
 doc/how_to/callbacks/server.md                |  25 +
 doc/how_to/callbacks/session.md               |  11 +
 doc/how_to/display/index.md                   |   0
 doc/how_to/export/bokeh.md                    |  17 +
 doc/how_to/export/embedding.md                |  43 ++
 doc/how_to/export/index.md                    |  13 +
 doc/how_to/export/saving.md                   |  18 +
 doc/how_to/index.md                           |  76 ++-
 doc/how_to/integrations/index.md              |  12 +-
 doc/how_to/state/busy.md                      |  23 +
 doc/how_to/state/index.md                     |  39 ++
 doc/how_to/state/request.md                   |  24 +
 doc/how_to/state/url.md                       |  55 +++
 doc/how_to/wasm/convert.md                    | 125 +++++
 doc/how_to/wasm/index.md                      |  60 +++
 doc/how_to/wasm/jupyterlite.md                |  24 +
 doc/how_to/wasm/sphinx.md                     | 122 +++++
 doc/how_to/wasm/standalone.md                 | 144 ++++++
 doc/user_guide/Authentication.md              | 218 ---------
 doc/user_guide/Running_in_Webassembly.md      | 431 ------------------
 doc/user_guide/index.rst                      |  32 --
 examples/user_guide/Display_and_Export.ipynb  | 143 ------
 .../Performance_and_Debugging.ipynb           | 142 +-----
 .../Session_State_and_Callbacks.ipynb         | 361 ---------------
 37 files changed, 1446 insertions(+), 1345 deletions(-)
 create mode 100644 doc/how_to/authentication/configuration.md
 create mode 100644 doc/how_to/authentication/index.md
 create mode 100644 doc/how_to/authentication/providers.md
 create mode 100644 doc/how_to/authentication/user_info.md
 create mode 100644 doc/how_to/caching/index.md
 create mode 100644 doc/how_to/caching/manual.md
 create mode 100644 doc/how_to/caching/memoization.md
 create mode 100644 doc/how_to/callbacks/async.md
 create mode 100644 doc/how_to/callbacks/index.md
 create mode 100644 doc/how_to/callbacks/load.md
 create mode 100644 doc/how_to/callbacks/periodic.md
 create mode 100644 doc/how_to/callbacks/schedule.md
 create mode 100644 doc/how_to/callbacks/server.md
 create mode 100644 doc/how_to/callbacks/session.md
 create mode 100644 doc/how_to/display/index.md
 create mode 100644 doc/how_to/export/bokeh.md
 create mode 100644 doc/how_to/export/embedding.md
 create mode 100644 doc/how_to/export/index.md
 create mode 100644 doc/how_to/export/saving.md
 create mode 100644 doc/how_to/state/busy.md
 create mode 100644 doc/how_to/state/index.md
 create mode 100644 doc/how_to/state/request.md
 create mode 100644 doc/how_to/state/url.md
 create mode 100644 doc/how_to/wasm/convert.md
 create mode 100644 doc/how_to/wasm/index.md
 create mode 100644 doc/how_to/wasm/jupyterlite.md
 create mode 100644 doc/how_to/wasm/sphinx.md
 create mode 100644 doc/how_to/wasm/standalone.md
 delete mode 100644 doc/user_guide/Authentication.md
 delete mode 100644 doc/user_guide/Running_in_Webassembly.md
 delete mode 100644 examples/user_guide/Session_State_and_Callbacks.ipynb

diff --git a/doc/conf.py b/doc/conf.py
index 31eabe22ba..2f7be6038f 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -41,7 +41,6 @@
 html_logo = "_static/logo_horizontal.png"
 html_favicon = "_static/icons/favicon.ico"
 
-
 html_theme_options = {
     "github_url": "https://github.com/holoviz/panel",
     "icon_links": [
diff --git a/doc/how_to/authentication/configuration.md b/doc/how_to/authentication/configuration.md
new file mode 100644
index 0000000000..4a69fa8463
--- /dev/null
+++ b/doc/how_to/authentication/configuration.md
@@ -0,0 +1,117 @@
+# Configuring OAuth
+
+The OAuth component will stop any user from accessing the application before first logging into the selected provider. The configuration to set up OAuth is all handled via the global `pn.config` object, which has a number of OAuth related parameters. When launching the application via the `panel serve` CLI command these config options can be set as CLI arguments or environment variables, when using the `pn.serve` function on the other hand these variables can be passed in as arguments.
+
+## `oauth_provider`
+
+The first step in configuring a OAuth is to specify a specific OAuth provider. Panel ships with a number of providers by default:
+
+* `azure`: Azure Active Directory
+* `bitbucket`: Bitbucket
+* `github`: GitHub
+* `gitlab`: GitLab
+* `google`: Google
+* `okta`: Okta
+
+We will go through the process of configuring each of these individually later but for now all we need to know that the `oauth_provider` can be set on the commandline using the `--oauth-provider` CLI argument to `panel serve` or the `PANEL_OAUTH_PROVIDER` environment variable.
+
+Examples:
+
+```
+panel serve oauth_example.py --oauth-provider=...
+
+PANEL_OAUTH_PROVIDER=... panel serve oauth_example.py
+```
+
+## `oauth_key` and `oauth_secret`
+
+To authenticate with a OAuth provider we generally require two pieces of information (although some providers will require more customization):
+
+1. The Client ID is a public identifier for apps.
+2. The Client Secret is a secret known only to the application and the authorization server.
+
+These can be configured in a number of ways the client ID and client secret can be supplied to the `panel serve` command as `--oauth-key` and `--oauth-secret` CLI arguments or `PANEL_OAUTH_KEY` and `PANEL_OAUTH_SECRET` environment variables respectively.
+
+Examples:
+
+```
+panel serve oauth_example.py --oauth-key=... --oauth-secret=...
+
+PANEL_OAUTH_KEY=... PANEL_OAUTH_KEY=... panel serve oauth_example.py ...
+```
+
+## `oauth_extra_params`
+
+Some OAuth providers will require some additional configuration options which will become part of the OAuth URLs. The `oauth_extra_params` configuration variable allows providing this additional information and can be set using the `--oauth-extra-params` CLI argument or `PANEL_OAUTH_EXTRA_PARAMS`.
+
+Examples:
+
+```
+panel serve oauth_example.py --oauth-extra-params={'tenant_id': ...}
+
+PANEL_OAUTH_EXTRA_PARAMS={'tenant_id': ...} panel serve oauth_example.py ...
+```
+
+## `cookie_secret`
+
+Once authenticated the user information and authorization token will be set as secure cookies. Cookies are not secure and can easily be modified by clients. A secure cookie ensures that the user information cannot be interfered with or forged by the client by signing it with a secret key. Note that secure cookies guarantee integrity but not confidentiality. That is, the cookie cannot be modified but its contents can be seen by the user. To generate a `cookie_secret` use the `panel secret` CLI argument or generate some other random non-guessable string, ideally with at least 256-bits of entropy.
+
+To set the `cookie_secret` supply `--cookie-secret` as a CLI argument or set the `PANEL_COOKIE_SECRET` environment variable.
+
+Examples:
+
+```
+panel serve oauth_example.py --cookie-secret=...
+
+PANEL_COOKIE_SECRET=... panel serve oauth_example.py ...
+```
+
+## `oauth_expiry`
+
+The OAuth expiry configuration value determines for how long an OAuth token will be valid once it has been issued. By default it is valid for 1 day, but may be overwritten by providing the duration in the number of days (decimal values are allowed).
+
+To set the `oauth_expiry` supply `--oauth-expiry-days` as a CLI argument or set the `PANEL_OAUTH_EXPIRY` environment variable.
+
+Examples:
+
+```
+panel serve oauth_example.py --oauth-expiry-days=...
+
+PANEL_OAUTH_EXPIRY=... panel serve oauth_example.py ...
+```
+
+## Encryption
+
+The architecture of the Bokeh/Panel server means that credentials stored as cookies can be leak in a number of ways. On the initial HTTP(S) request the server will respond with the HTML document that renders the application and this will include an unencrypted token containing the OAuth information. To ensure that the user information and access token are properly encrypted we rely on the Fernet encryption in the `cryptography` library. You can install it with `pip install cryptography` or `conda install cryptography`.
+
+Once installed you will be able to generate a encryption key with `panel oauth-secret`. This will generate a secret you can pass to the `panel serve` CLI command using the ``--oauth-encryption-key`` argument or `PANEL_OAUTH_ENCRYPTION` environment variable.
+
+Examples:
+
+```
+panel serve oauth_example.py --oauth-encryption-key=...
+
+PANEL_OAUTH_ENCRYPTION=... panel serve oauth_example.py ...
+```
+
+## Redirect URI
+
+Once the OAuth provider has authenticated a user it has to redirect them back to the application, this is what is known as the redirect URI. For security reasons this has to match the URL registered with the OAuth provider exactly. By default Panel will redirect the user straight back to the original URL of your app, e.g. when you're hosting your app at `https://myapp.myprovider.com` Panel will use that as the redirect URI. However in certain scenarios you may override this to provide a specific redirect URI. This can be achieved with the `--oauth-redirect-uri` CLI argument or the `PANEL_OAUTH_REDIRECT_URI` environment variable.
+
+Examples:
+
+```
+panel serve oauth_example.py --oauth-redirect-uri=...
+
+PANEL_OAUTH_REDIRECT_URI=... panel serve oauth_example.py
+```
+
+## Summary
+
+A fully configured OAuth configuration may look like this:
+
+```
+panel serve oauth_example.py --oauth-provider=github --oauth-key=... --oauth-secret=... --cookie-secret=... --oauth-encryption-key=...
+
+PANEL_OAUTH_PROVIDER=... PANEL_OAUTH_KEY=... PANEL_OAUTH_SECRET=... PANEL_COOKIE_SECRET=... PANEL_OAUTH_ENCRYPTION=... panel serve oauth_example.py ...`
+```
\ No newline at end of file
diff --git a/doc/how_to/authentication/index.md b/doc/how_to/authentication/index.md
new file mode 100644
index 0000000000..66d088f1e3
--- /dev/null
+++ b/doc/how_to/authentication/index.md
@@ -0,0 +1,51 @@
+# Configuring Authentication
+
+Authentication is a difficult topic fraught with potential pitfalls and complicated configuration options. Panel aims to be a "batteries-included" package for building applications and dashboards and therefore ships with a number of inbuilt providers for authentication in an application.
+
+The primary mechanism by which Panel performs autentication is [OAuth 2.0](https://oauth.net/2/). The official specification for OAuth 2.0 describes the protocol as follows:
+
+    The OAuth 2.0 authorization framework enables a third-party
+    application to obtain limited access to an HTTP service, either on
+    behalf of a resource owner by orchestrating an approval interaction
+    between the resource owner and the HTTP service, or by allowing the
+    third-party application to obtain access on its own behalf.
+
+In other words OAuth outsources authentication to a third party provider, e.g. GitHub, Google or Azure AD, to authenticate the user credentials and give limited access to the APIs of that service.
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`gear;2.5em;sd-mr-1` Configuring OAuth
+:link: configuration
+:link-type: doc
+
+Discover how to configure OAuth from the commandline.
+:::
+
+:::{grid-item-card} {octicon}`shield;2.5em;sd-mr-1` OAuth Providers
+:link: providers
+:link-type: doc
+
+A list of OAuth providers and how to configure them.
+:::
+
+:::{grid-item-card} {octicon}`shield-check;2.5em;sd-mr-1` User Information
+:link: user_info
+:link-type: doc
+
+Discover how to make use of the user information and access tokens returned by the OAuth provider. 
+:::
+
+::::
+
+Note that since Panel is built on Bokeh server and Tornado it is also possible to implement your own authentication independent of the OAuth components shipped with Panel, [see the Bokeh documentation](https://docs.bokeh.org/en/latest/docs/user_guide/server.html#authentication) for further information.
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+configuration
+providers
+user_info
+```
diff --git a/doc/how_to/authentication/providers.md b/doc/how_to/authentication/providers.md
new file mode 100644
index 0000000000..4922d577ec
--- /dev/null
+++ b/doc/how_to/authentication/providers.md
@@ -0,0 +1,45 @@
+# OAuth Providers
+
+Panel supports a number of OAuth providers out-of-the-box. Follow the guide for setting up an OAuth application specific to your provider and then refer to the [Configuring OAuth guide](configuration) to add OAuth to your application.
+
+## **Azure Active Directory**
+
+To set up OAuth2.0 authentication for Azure Active directory follow [these instructions](https://docs.microsoft.com/en-us/azure/api-management/api-management-howto-protect-backend-with-aad). In addition to the `oauth_key` and `oauth_secret` ensure that you also supply the tenant ID using `oauth_extra_params`, e.g.:
+
+```
+panel serve oauth_test.py --oauth-extra-params="{'tenant': '...'}"
+
+PANEL_OAUTH_EXTRA_PARAMS="{'tenant': '...'}" panel serve oauth_example.py ...
+```
+
+## **Bitbucket**
+
+Bitbucket provides instructions about setting [setting up an OAuth consumer](https://support.atlassian.com/bitbucket-cloud/docs/use-oauth-on-bitbucket-cloud/). Follow these and then supply the `oauth_key` and `oauth_secret` to Panel as described above.
+
+## **GitHub**
+
+GitHub provides detailed instructions on [creating an OAuth app](https://developer.github.com/apps/building-oauth-apps/creating-an-oauth-app/). Follow these and then supply the `oauth_key` and `oauth_secret` to Panel as described above.
+
+## **GitLab**
+
+GitLab provides a detailed guide on [configuring an OAuth](https://docs.gitlab.com/ee/api/oauth2.html) application. In addition to the `oauth_key` and `oauth_secret` you will also have to supply a custom url using the `oauth_extra_params` if you have a custom GitLab instance (the default `oauth_extra_params={'url': 'gitlab.com'}`).
+
+## **Google**
+
+Google provides a guide about [configuring a OAuth application](https://developers.google.com/identity/protocols/oauth2/native-app). By default nothing except the `oauth_key` and `oauth_secret` are required but to access Google services you may also want to override the default `scope` via the `oauth_extra_params`.
+
+## **Okta**
+
+Okta provides a guide about [configuring OAuth2](https://developer.okta.com/docs/concepts/oauth-openid/). You must provide an `oauth_key` and `oauth_secret` but in most other ordinary setups you will also have to provide a `url` via the `oauth_extra_params` and if you have set up a custom authentication server (i.e. not 'default') with Okta you must also provide 'server', the `oauth_extra_params` should then look something like this: `{'server': 'custom', 'url': 'dev-***.okta.com'}`
+
+## Plugins
+
+The Panel OAuth providers are pluggable, in other words downstream libraries may define their own Tornado `RequestHandler` to be used with Panel. To register such a component the `setup.py` of the downstream package should register an entry_point that Panel can discover. To read more about entry points see the [Python documentation](https://packaging.python.org/specifications/entry-points/). A custom OAuth request handler in your library may be registered as follows:
+
+```python
+entry_points={
+    'panel.auth': [
+        "custom = my_library.auth:MyCustomOAuthRequestHandler"
+    ]
+}
+```
diff --git a/doc/how_to/authentication/user_info.md b/doc/how_to/authentication/user_info.md
new file mode 100644
index 0000000000..70cc5971f5
--- /dev/null
+++ b/doc/how_to/authentication/user_info.md
@@ -0,0 +1,40 @@
+# Accessing User information
+
+## User State
+
+Once a user is authorized with the chosen OAuth provider certain user information and an `access_token` will be available to be used in the application to customize the user experience. Like all other global state this may be accessed on the `pn.state` object, specifically it makes three attributes available:
+
+* **`pn.state.user`**: A unique name, email or ID that identifies the user.
+* **`pn.state.access_token`**: The access token issued by the OAuth provider to authorize requests to its APIs.
+* **`pn.state.refresh_token`**: The refresh token issued by the OAuth provider to authorize requests to its APIs (if available these are usually longer lived than the `access_token`).
+* **`pn.state.user_info`**: Additional user information provided by the OAuth provider. This may include names, email, APIs to request further user information, IDs and more.
+
+## Authorization callbacks
+
+The OAuth providers integrated with Panel provide an easy way to enable authentication on your applications. This verifies the identity of a user and also provides some level of access control (i.e. authorization). However often times the OAuth configuration is controlled by a corporate IT department or is otherwise difficult to manage so its often easier to grant permissions to use the OAuth provider freely but then restrict access controls in the application itself. To manage access you can provide an `authorization_callback` as part of your applications.
+
+The `authorization_callback` can be configured on `pn.config` or via the `pn.extension`:
+
+```python
+import panel as pn
+
+def authorize(user_info):
+    with open('users.txt') as f:
+        valid_users = f.readlines()
+    return user_info['username'] in valid_users
+
+pn.config.authorize_callback = authorize # or pn.extension(..., authorize_callback=authorize)
+```
+
+The `authorize_callback` is given a dictionary containing the data in the OAuth provider's `id_token`. The example above checks whether the current user is in the list of users specified in a `user.txt` file. However you can implement whatever logic you want to either grant a user access or reject it.
+
+If a user is not authorized they will be presented with a authorization error template which can be configured using the `--auth-template` commandline option or by setting `config.auth_template`.
+
+<img src="../../_static/authorization.png" width="600" style="margin-left: auto; margin-right: auto; display: block;"></img>
+
+The auth template must be a valid Jinja2 template and accepts a number of arguments:
+
+- `{{ title }}`: The page title.
+- `{{ error_type }}`: The type of error.
+- `{{ error }}`: A short description of the error.
+- `{{ error_msg }}`: A full description of the error.
diff --git a/doc/how_to/caching/index.md b/doc/how_to/caching/index.md
new file mode 100644
index 0000000000..9b48e4664e
--- /dev/null
+++ b/doc/how_to/caching/index.md
@@ -0,0 +1,31 @@
+# Caching
+
+Caching data and computation is one of the most effective ways to speed up your applications. Some common examples of scenarios that benefit from caching is working with large datasets that you have to load from disk or over a network connection or you have to perform expensive computations that don't depend on any extraneous state. Panel makes it easy for you to add caching to you applications using a few approaches. Panel' architecture is also very well suited towards caching since multiple user sessions can run in the same process and therefore have access to the same global state. This means that we can cache data in Panel's global `state` object, either by directly assigning to the `pn.state.cache` dictionary object, using the `pn.state.as_cached` helper function or the `pn.cache` decorator. Once cached all current and subsequent sessions will be sped up by having access to the cache.
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` Manual Caching
+:link: manual
+:link-type: doc
+
+How to manually cache data and objects on `pn.state.cache`.
+:::
+
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` Memoization
+:link: memoization
+:link-type: doc
+
+How to use the `panel.cache` decorator to memoize (i.e. cache the output of) functions automatically.
+:::
+
+::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+manual
+memoization
+```
\ No newline at end of file
diff --git a/doc/how_to/caching/manual.md b/doc/how_to/caching/manual.md
new file mode 100644
index 0000000000..2205e9fc54
--- /dev/null
+++ b/doc/how_to/caching/manual.md
@@ -0,0 +1,23 @@
+# Manual caching
+
+The `panel.state.cache` object is a simple dictionary that is shared between all sessions on a particular Panel server process. This makes it possible to load large datasets (or other objects you want to share) once and subsequently access the cached object.
+
+To assign to the cache manually, simply put the data load or expensive calculation in an `if`/`else` block which checks whether the custom key is already present: 
+
+```python
+if 'data' in pn.state.cache:
+    data = pn.state.cache['data']
+else:
+    pn.state.cache['data'] = data = ... # Load some data or perform an expensive computation
+```
+
+The `as_cached` helper function provides a slightly cleaner way to write the caching logic. Instead of writing a conditional statement you write a function that is executed only when the inputs to the function change. If provided the `args` and `kwargs` will also be hashed making it easy to cache (or memoize) on the arguments to the function: 
+
+```python
+def load_data(*args, **kwargs):
+    return ... # Load some data
+
+data = pn.state.as_cached('data', load_data, *args, **kwargs)
+```
+
+The first time the app is loaded the data will be cached and subsequent sessions will simply look up the data in the cache, speeding up the process of rendering. If you want to warm up the cache before the first user visits the application you can also provide the `--warm` argument to the `panel serve` command, which will ensure the application is initialized as soon as it is launched. If you want to populate the cache in a separate script from your main application you may also provide the path to a setup script using the `--setup` argument to `panel serve`. If you want to periodically update the cache look into the ability to [schedule tasks](../callbacks/schedule).
diff --git a/doc/how_to/caching/memoization.md b/doc/how_to/caching/memoization.md
new file mode 100644
index 0000000000..1ba246ccde
--- /dev/null
+++ b/doc/how_to/caching/memoization.md
@@ -0,0 +1,45 @@
+# Memoization
+
+The `pn.cache` decorator provides an easy way to cache the outputs of a function depending on its inputs (i.e. `memoize`). If you've ever used the Python `@lru_cache` decorator you will be familiar with this concept. However the `pn.cache` functions supports additional cache `policy`'s apart from LRU (least-recently used), including `LFU` (least-frequently-used) and 'FIFO' (first-in-first-out). This means that if the specified number of `max_items` is reached Panel will automatically evict items from the cache based on this `policy`. Additionally items can be deleted from the cache based on a `ttl` (time-to-live) value given in seconds.
+
+## Caching in memory
+
+The `pn.cache` decorator can easily be combined with the different Panel APIs including `pn.bind` and `pn.depends` providing a powerful way to speed up your applications.
+
+```python
+@pn.cache(max_items=10, policy='LRU')
+def load_data(path):
+    return ... # Load some data
+```
+
+Once you have decorated your function with `pn.cache` any call to `load_data` will be cached in memory until `max_items` value is reached (i.e. you have loaded 10 different `path` values). At that point the `policy` will determine which item is evicted.
+
+The `pn.cache` decorator can easily be combined with `pn.bind` to speed up rendering of your reactive components:
+
+```{pyodide}
+import pandas as pd
+import panel as pn
+
+pn.extension('tabulator')
+
+select = pn.widgets.Select(options={
+    'Penguins': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv',
+    'Diamonds': 'https://raw.githucbusercontent.com/mwaskom/seaborn-data/master/diamonds.csv',
+    'Titanic': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv',
+    'MPG': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv'
+})
+
+@pn.cache
+def fetch_data(url):
+    return pd.read_csv(url)
+
+pn.Column(select, pn.bind(pn.widgets.Tabulator, pn.bind(fetch_data, select), page_size=10))
+```
+
+## Disk caching
+
+If you have `diskcache` installed you can also cache the results to disk by setting `to_disk=True`. The `diskcache` library will then cache the value to the supplied `cache_path` (defaulting to `./cache`). Making use of disk caching allows you to cache items even if the server is restarted.
+
+## Clearing the cache
+
+Once a function has been decorated with `pn.cache` you can easily clear the cache by calling `.clear()` on that function, e.g. in the example above you could call `load_data.clear()`. If you want to clear all caches you may also call `pn.state.clear_caches()`.
diff --git a/doc/how_to/callbacks/async.md b/doc/how_to/callbacks/async.md
new file mode 100644
index 0000000000..67bd3032aa
--- /dev/null
+++ b/doc/how_to/callbacks/async.md
@@ -0,0 +1,92 @@
+## Asynchronous callbacks
+
+Python has natively supported asynchronous functions since version 3.5, for a quick overview of some of the concepts involved see [the Python documentation](https://docs.python.org/3/library/asyncio-task.html). For full asyncio support in Panel you will have to use `python>=3.8`.
+
+## `.param.watch`
+
+One of the major benefits of leveraging async functions is that it is simple to write callbacks which will perform some longer running IO tasks in the background. Below we simulate this by creating a `Button` which will update some text when it starts and finishes running a long-running background task (here simulated using `asyncio.sleep`. If you are running this in the notebook you will note that you can start multiple tasks and it will update the text immediately but continue in the background:
+
+```{pyodide}
+import panel as pn
+import asyncio
+
+pn.extension()
+
+button = pn.widgets.Button(name='Click me!')
+text = pn.widgets.StaticText()
+
+async def run_async(event):
+    text.value = f'Running {event.new}'
+    await asyncio.sleep(2)
+    text.value = f'Finished {event.new}'
+
+button.on_click(run_async)
+
+pn.Row(button, text)
+```
+
+Note that `on_click` is simple one way of registering an asynchronous callback, using `.param.watch` is also supported and so is scheduling asynchronous periodic callbacks with `pn.state.add_periodic_callback`.
+
+It is important to note that asynchronous callbacks operate without locking the underlying bokeh Document, which means Bokeh models cannot be safely modified by default. Usually this is not an issue because modifying Panel components appropriately schedules updates to underlying Bokeh models, however in cases where we want to modify a Bokeh model directly, e.g. when embedding and updating a Bokeh plot in a Panel application we explicitly have to decorate the asynchronous callback with `pn.io.with_lock`.
+
+```{pyodide}
+import numpy as np
+from bokeh.plotting import figure
+from bokeh.models import ColumnDataSource
+
+button = pn.widgets.Button(name='Click me!')
+
+p = figure(width=500, height=300)
+cds = ColumnDataSource(data={'x': [0], 'y': [0]})
+p.line(x='x', y='y', source=cds)
+pane = pn.pane.Bokeh(p)
+
+@pn.io.with_lock
+async def stream(event):
+    await asyncio.sleep(1)
+    x, y = cds.data['x'][-1], cds.data['y'][-1]
+    cds.stream({'x': list(range(x+1, x+6)), 'y': y+np.random.randn(5).cumsum()})
+    pane.param.trigger('object')
+    
+# Equivalent to `.on_click` but shown
+button.param.watch(stream, 'clicks')
+
+pn.Row(button, pane)
+```
+
+## `pn.bind`
+
+```{pyodide}
+import aiohttp
+
+widget = pn.widgets.IntSlider(start=0, end=10)
+
+async def get_img(index):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"https://picsum.photos/800/300?image={index}") as resp:
+            return pn.pane.JPG(await resp.read())
+            
+pn.Column(widget, pn.bind(get_img, widget))
+```
+
+In this example Panel will invoke the function and update the output when the function returns while leaving the process unblocked for the duration of the `aiohttp` request. 
+
+The equivalent can be written using `.param.watch` as:
+
+```{pyodide}
+widget = pn.widgets.IntSlider(start=0, end=10)
+
+image = pn.pane.JPG()
+
+async def update_img(event):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"https://picsum.photos/800/300?image={event.new}") as resp:
+            image.object = await resp.read()
+            
+widget.param.watch(update_img, 'value')
+widget.param.trigger('value')
+            
+pn.Column(widget, image)
+```
+
+In this example Param will await the asynchronous function and the image will be updated when the request completes.
diff --git a/doc/how_to/callbacks/index.md b/doc/how_to/callbacks/index.md
new file mode 100644
index 0000000000..a627cf2829
--- /dev/null
+++ b/doc/how_to/callbacks/index.md
@@ -0,0 +1,61 @@
+# Session callbacks and events
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` Asynchronous callbacks
+:link: async
+:link-type: doc
+
+How to leverage asynchronous callbacks to run I/O bound tasks in parallel.
+:::
+
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` Load callbacks
+:link: session
+:link-type: doc
+
+How to set up callbacks to defer a task until the application is loaded.
+:::
+
+:::{grid-item-card} {octicon}`sync;2.5em;sd-mr-1` Periodic callbacks
+:link: periodic
+:link-type: doc
+
+How to set up per-session callbacks that run periodically.
+:::
+
+:::{grid-item-card} {octicon}`note;2.5em;sd-mr-1` Session callbacks
+:link: session
+:link-type: doc
+
+How to set up callbacks when a session is created and destroyed.
+:::
+
+:::{grid-item-card} {octicon}`calendar;2.5em;sd-mr-1` Schedule Tasks
+:link: schedule
+:link-type: doc
+
+How to schedule tasks that run independently of any user visiting the application(s).
+:::
+
+:::{grid-item-card} {octicon}`lock;2.5em;sd-mr-1` Bokeh Server callbacks
+:link: server
+:link-type: doc
+
+How to safely modify Bokeh models to avoid running into issues with the Bokeh `Document` lock.
+:::
+
+::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+async
+load
+session
+periodic
+schedule
+server
+```
\ No newline at end of file
diff --git a/doc/how_to/callbacks/load.md b/doc/how_to/callbacks/load.md
new file mode 100644
index 0000000000..ba4f7ad11c
--- /dev/null
+++ b/doc/how_to/callbacks/load.md
@@ -0,0 +1,31 @@
+# Load callbacks
+
+Another useful callback to define the onload callback, in a server context this will execute when a session is first initialized. Let us for example define a minimal example inside a function which we will pass to `pn.serve`. This emulates what happens when we call `panel serve` on the commandline. We will create a widget without populating its options, then we will add an `onload` callback, which will set the options once the initial page is loaded. Imagine for example that we have to fetch the options from some database which might take a little while, by deferring the loading of the options to the callback we can get something on the screen as quickly as possible and only run the expensive callback when we have already rendered something for the user to look at.
+
+```{pyodide}
+import time
+
+import panel as pn
+
+def app():
+    widget = pn.widgets.Select()
+
+    def on_load():
+        time.sleep(1) # Emulate some long running process
+        widget.options = ['A', 'B', 'C']
+
+    pn.state.onload(on_load)
+
+    return widget
+
+# pn.serve(app)
+```
+
+Alternatively we may also use the `defer_load` option to wait to evaluate a function until the page is loaded. This will render a placeholder and display the global `config.loading_spinner`:
+
+```{pyodide}
+def render_on_load():
+    return pn.widgets.Select(options=['A', 'B', 'C'])
+
+pn.Row(pn.panel(render_on_load, defer_load=True))
+```
diff --git a/doc/how_to/callbacks/periodic.md b/doc/how_to/callbacks/periodic.md
new file mode 100644
index 0000000000..ccfea09aa4
--- /dev/null
+++ b/doc/how_to/callbacks/periodic.md
@@ -0,0 +1,64 @@
+# Periodic callbacks
+
+Periodic callbacks allow periodically updating your application with new data. Below we will create a simple Bokeh plot and display it with Panel:
+
+```{pyodide}
+import panel as pn
+
+from bokeh.models import ColumnDataSource
+from bokeh.plotting import figure
+
+source = ColumnDataSource({"x": range(10), "y": range(10)})
+p = figure()
+p.line(x="x", y="y", source=source)
+
+bokeh_pane = pn.pane.Bokeh(p)
+bokeh_pane.servable()
+```
+
+Now we will define a callback that updates the data on the `ColumnDataSource` and use the `pn.state.add_periodic_callback` method to schedule updates every 200 ms. We will also set a timeout of 5 seconds after which the callback will automatically stop.
+
+```{pyodide}
+def update():
+    data = np.random.randint(0, 2 ** 31, 10)
+    source.data.update({"y": data})
+    bokeh_pane.param.trigger('object') # Only needed in notebook
+
+cb = pn.state.add_periodic_callback(update, 200)
+```
+
+In a notebook or bokeh server context we should now see the plot update periodically. The other nice thing about this is that `pn.state.add_periodic_callback` returns `PeriodicCallback` we can call `.stop()` and `.start()` on if we want to stop or pause the periodic execution. Additionally we can also dynamically adjust the period by setting the `timeout` parameter to speed up or slow down the callback.
+
+Other nice features on a periodic callback are the ability to check the number of executions using the `cb.counter` property and the ability to toggle the callback on and off simply by setting the running parameter. This makes it possible to link a widget to the running state:
+
+```{pyodide}
+toggle = pn.widgets.Toggle(name='Toggle callback', value=True)
+
+toggle.link(cb, bidirectional=True, value='running')
+toggle
+```
+
+Note that when starting a server dynamically with `pn.serve` you cannot start a periodic callback before the application is actually being served. Therefore you should create the application and start the callback in a wrapping function:
+
+```python
+from functools import partial
+
+import numpy as np
+import panel as pn
+
+from bokeh.models import ColumnDataSource
+from bokeh.plotting import figure
+
+def update(source):
+    data = np.random.randint(0, 2 ** 31, 10)
+    source.data.update({"y": data})
+
+def panel_app():
+    source = ColumnDataSource({"x": range(10), "y": range(10)})
+    p = figure()
+    p.line(x="x", y="y", source=source)
+    cb = pn.state.add_periodic_callback(partial(update, source), 200, timeout=5000)
+    return pn.pane.Bokeh(p)
+
+pn.serve(panel_app)
+```
\ No newline at end of file
diff --git a/doc/how_to/callbacks/schedule.md b/doc/how_to/callbacks/schedule.md
new file mode 100644
index 0000000000..5e48ae3aa6
--- /dev/null
+++ b/doc/how_to/callbacks/schedule.md
@@ -0,0 +1,32 @@
+# Scheduling Tasks
+
+The `pn.state.schedule_task` functionality allows scheduling global tasks at certain times or on a specific schedule. This is distinct from periodic callbacks, which are scheduled per user session. Global tasks are useful for performing periodic actions like updating cached data, performing cleanup actions or other housekeeping tasks, while periodic callbacks should be reserved for making periodic updates to an application.
+
+The different contexts in which global tasks and periodic callbacks run also has implications on how they should be scheduled. Scheduled task **must not** be declared in the application code itself, i.e. if you are serving `panel serve app.py` the callback you are scheduling must not be declared in the `app.py`. It must be defined in an external module or in a separate script declared as part of the `panel serve` invocation using the `--setup` commandline argument.
+
+Scheduling using `pn.state.schedule_task` is idempotent, i.e. if a callback has already been scheduled under the same name subsequent calls will have no effect. By default the starting time is immediate but may be overridden with the `at` keyword argument. The period may be declared using the `period` argument or a cron expression (which requires the `croniter` library). Note that the `at` time should be in local time but if a callable is provided it must return a UTC time. If `croniter` is installed a `cron` expression can be provided using the `cron` argument.
+
+As a simple example of a task scheduled at a fixed interval:
+
+```python
+import datetime as dt
+import asyncio
+
+async def task():
+    print(f'Task executed at: {dt.datetime.now()}')
+
+pn.state.schedule_task('task', task, period='1s')
+await asyncio.sleep(3)
+
+pn.state.cancel_task('task')
+```
+
+Note that while both `async` and regular callbacks are supported, asynchronous callbacks are preferred if you are performing any I/O operations to avoid interfering with any running applications.
+
+If you have the `croniter` library installed you may also provide a cron expression, e.g. the following will schedule a task to be repeated at 4:02 am every Monday and Friday:
+
+```python
+pn.state.schedule_task('task', task, cron='2 4 * * mon,fri')
+```
+
+See [crontab.guru](https://crontab.guru/) and the [`croniter` README](https://github.com/kiorky/croniter#introduction) to learn about cron expressions genrally and special syntax supported by `croniter`.
\ No newline at end of file
diff --git a/doc/how_to/callbacks/server.md b/doc/how_to/callbacks/server.md
new file mode 100644
index 0000000000..59af138cd2
--- /dev/null
+++ b/doc/how_to/callbacks/server.md
@@ -0,0 +1,25 @@
+# Server Callbacks
+
+The Bokeh server that Panel builds on is designed to be thread safe which requires a set of locks to avoid multiple threads modifying the Bokeh models simultaneously.  Panel being a high-level wrapper around Bokeh handles this locking for you. However, when you update Bokeh components directly you may need to schedule a callback to get around Bokeh's document lock to avoid errors like this:
+
+```
+RuntimeError: _pending_writes should be non-None when we have a document lock, and we should have the lock when the document changes
+```
+
+In the example below we will launch an application on a thread using `pn.serve` and make the Bokeh plot (in practice you may provide handles to this object on a class). To schedule schedule a callback which updates the `y_range` by using the `pn.state.execute` method. This pattern will ensure that the update to the Bokeh model is executed on the correct thread:
+
+```python
+import time
+import panel as pn
+
+from bokeh.plotting import figure
+
+def app():
+    p = figure()
+    p.line([1, 2, 3], [1, 2, 3])
+    return p
+
+pn.serve(app, threaded=True)
+
+pn.state.execute(lambda: p.y_range.update(start=0, end=4))
+```
\ No newline at end of file
diff --git a/doc/how_to/callbacks/session.md b/doc/how_to/callbacks/session.md
new file mode 100644
index 0000000000..2531bef7cb
--- /dev/null
+++ b/doc/how_to/callbacks/session.md
@@ -0,0 +1,11 @@
+# Session callbacks
+
+Whenever a request is made to an endpoint that is serving a Panel application a new session is created. If you have to perform some setup or tear down tasks on session creation (e.g. logging) you can define `on_session_created` and `on_session_destroyed` callbacks. 
+
+## pn.state.on_session_created
+
+WIP
+
+## pn.state.on_session_destroyed
+
+In many cases it is useful to define on_session_destroyed callbacks to perform any custom cleanup that is required, e.g,  dispose  a database engine, or when a user is logged out. These callbacks can be registered with `pn.state.on_session_destroyed(callback)`
\ No newline at end of file
diff --git a/doc/how_to/display/index.md b/doc/how_to/display/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/doc/how_to/export/bokeh.md b/doc/how_to/export/bokeh.md
new file mode 100644
index 0000000000..09d26b05c4
--- /dev/null
+++ b/doc/how_to/export/bokeh.md
@@ -0,0 +1,17 @@
+# Accessing the Bokeh model
+
+Since Panel is built on top of Bokeh, all Panel objects can easily be converted to a Bokeh model. The ``get_root`` method returns a model representing the contents of a Panel:
+
+```python
+model = pn.Column('# Some markdown').get_root()
+model
+```
+
+By default this model will be associated with Bokeh's ``curdoc()``, so if you want to associate the model with some other ``Document`` ensure you supply it explictly as the first argument. Once you have access to the underlying bokeh model you can use all the usual bokeh utilities such as ``components``, ``file_html``, or ``show``
+
+```python
+from bokeh.embed import components, file_html
+from bokeh.io import show
+
+script, html = components(model)
+```
\ No newline at end of file
diff --git a/doc/how_to/export/embedding.md b/doc/how_to/export/embedding.md
new file mode 100644
index 0000000000..276abb5af9
--- /dev/null
+++ b/doc/how_to/export/embedding.md
@@ -0,0 +1,43 @@
+# Embedding state
+
+Panel generally relies on either the Jupyter kernel or a Bokeh Server to be running in the background to provide interactive behavior. However for simple apps with a limited amount of state it is also possible to `embed` all the widget state, allowing the app to be used entirely from within Javascript. To demonstrate this we will create a simple app which simply takes a slider value, multiplies it by 5 and then display the result.
+
+```
+slider = pn.widgets.IntSlider(start=0, end=10)
+
+@pn.depends(slider.param.value)
+def callback(value):
+    return '%d * 5 = %d' % (value, value*5)
+
+row = pn.Row(slider, callback)
+```
+
+If we displayed this the normal way it would call back into Python every time the value changed. However, the `.embed()` method will record the state of the app for the different widget configurations.
+
+```
+row.embed()
+```
+
+If you try the widget above you will note that it only has 3 different states, 0, 5 and 10. This is because by default embed will try to limit the number of options of non-discrete or semi-discrete widgets to at most three values. This can be controlled using the `max_opts` argument to the embed method or you can provide an explicit list of `states` to embed for each widget:
+
+```
+row.embed(states={slider: list(range(0, 12, 2))})
+```
+
+ The full set of options for the embed method include:
+
+- **`max_states`**: The maximum number of states to embed
+
+- **`max_opts`**: The maximum number of states for a single widget
+
+- **`states`** (default={}): A dictionary specifying the widget values to embed for each widget
+
+- **`json`** (default=True): Whether to export the data to json files
+
+- **`save_path`** (default='./'): The path to save json files to
+
+- **`load_path`** (default=None):  The path or URL the json files will be loaded from (same as ``save_path`` if not specified)
+
+* **`progress`** (default=False): Whether to report progress
+
+As you might imagine if there are multiple widgets there can quickly be a combinatorial explosion of states so by default the output is limited to about 1000 states. For larger apps the states can also be exported to json files, e.g. if you want to serve the app on a website specify the ``save_path`` to declare where it will be stored and the ``load_path`` to declare where the JS code running on the website will look for the files.
\ No newline at end of file
diff --git a/doc/how_to/export/index.md b/doc/how_to/export/index.md
new file mode 100644
index 0000000000..885c325670
--- /dev/null
+++ b/doc/how_to/export/index.md
@@ -0,0 +1,13 @@
+# Exporting and Saving Output
+
+One of the main design goals for Panel was that it should make it possible to seamlessly transition back and forth between interactively prototyping a dashboard in the notebook or on the commandline to deploying it as a standalone server app. This section shows how to display panels interactively, embed static output, save a snapshot, and deploy as a separate web-server app. For more information about deploying Panel apps to various cloud providers see the [Server Deployment](Server_Deployment.ipynb) documentation.
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+embedding
+saving
+bokeh
+```
\ No newline at end of file
diff --git a/doc/how_to/export/saving.md b/doc/how_to/export/saving.md
new file mode 100644
index 0000000000..27d60966a8
--- /dev/null
+++ b/doc/how_to/export/saving.md
@@ -0,0 +1,18 @@
+# Saving output 
+
+In case you don't need an actual server or simply want to export a static snapshot of a panel app, you can use the ``save`` method, which allows exporting the app to a standalone HTML or PNG file.
+
+By default, the HTML file generated will depend on loading JavaScript code for BokehJS from the online ``CDN`` repository, to reduce the file size. If you need to work in an airgapped or no-network environment, you can declare that ``INLINE`` resources should be used instead of ``CDN``:
+
+```python
+from bokeh.resources import INLINE
+panel.save('test.html', resources=INLINE)
+```
+
+Additionally the save method also allows enabling the `embed` option, which, as explained above, will embed the apps state in the app or save the state to json files which you can ship alongside the exported HTML.
+
+Finally, if a 'png' file extension is specified, the exported plot will be rendered as a PNG, which currently requires Selenium and PhantomJS to be installed:
+
+```python
+pane.save('test.png')
+```
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index f6f637b5d5..c91f5dba3b 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -2,49 +2,93 @@
 
 The Panel's How to Guides provide step by step recipes for solving essential problems and tasks. They are more advanced than the Getting Started material and assume some knowledge of how Panel works.
 
-## Configuring a Panel Server
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
 
-## Deployment
+:::{grid-item-card} {octicon}`note;2.5em;sd-mr-1` Session callbacks and events
+:link: callbacks/index
+:link-type: doc
 
-The deployment guides provide step-by-step instructions on deploying Panel applications to various cloud providers.
+How to set up callbacks on session related events and periodic tasks.
+:::
 
-::::{grid} 2 3 3 5
-:gutter: 1 1 1 2
+:::{grid-item-card} {octicon}`note;2.5em;sd-mr-1` Accessing session state
+:link: state/index
+:link-type: doc
+
+How to access state related to the user session, HTTP request and URL arguments.
+:::
 
-:::{grid-item-card} Azure
-:link: deployment/azure
+:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Caching
+:link: caching/index
 :link-type: doc
+
+How to cache data across sessions and memoize the output of functions.
 :::
 
-:::{grid-item-card} Binder
-:link: deployment/binder
+:::{grid-item-card} {octicon}`device-desktop;2.5em;sd-mr-1` Display and Preview output
+:link: display/index
 :link-type: doc
+
+How to display Panel components and apps in your favorite notebook or editor environment.
 :::
 
-:::{grid-item-card} Google Cloud
-:link: deployment/gcp
+:::{grid-item-card} {octicon}`file;2.5em;sd-mr-1` Exporting and Saving output
+:link: export/index
 :link-type: doc
+
+How to export and save Panel applications as static files.
 :::
 
-:::{grid-item-card} Heroku
-:link: deployment/heroku
+:::{grid-item-card} {octicon}`browser;2.5em;sd-mr-1` Running in WebAssembly
+:link: wasm/index
 :link-type: doc
+
+How to run Panel applications entirely in the browser using WebAssembly, Pyodide and PyScript.
 :::
 
-:::{grid-item-card} Hugging Face
-:link: deployment/huggingface
+:::{grid-item-card} {octicon}`server;2.5em;sd-mr-1` Server Configuration
+:link: server/index
 :link-type: doc
+
+How to configure the Panel server.
 :::
 
-::::
+:::{grid-item-card} {octicon}`package-dependencies;2.5em;sd-mr-1` Server Integrations
+:link: integrations/index
+:link-type: doc
+
+How to integrate Panel in other application based on Flask, FastAPI or Django.
+:::
+
+:::{grid-item-card} {octicon}`share;2.5em;sd-mr-1` Deploying applications
+:link: deployment/index
+:link-type: doc
+
+How to deploy Panel applications to various cloud providers (e.g. Azure, GCP, AWS etc.)
+:::
+
+:::{grid-item-card} {octicon}`shield-check;2.5em;sd-mr-1` Authentication
+:link: authentication/index
+:link-type: doc
 
+How to configure OAuth to add authentication to a server deployment.
+:::
+
+::::
 
 ```{toctree}
 :titlesonly:
 :hidden:
 :maxdepth: 2
 
+callbacks/index
+state/index
+caching/index
+export/index
+wasm/index
 server/index
 integrations/index
 deployment/index
+authentication/index
 ```
\ No newline at end of file
diff --git a/doc/how_to/integrations/index.md b/doc/how_to/integrations/index.md
index c82cf38a27..66f6ab21d0 100644
--- a/doc/how_to/integrations/index.md
+++ b/doc/how_to/integrations/index.md
@@ -2,22 +2,28 @@
 
 These guides will cover how to integrate Panel applications with various external frameworks such as Django, FastAPI and Flask.
 
-::::{grid} 2 3 3 5
+::::{grid} 1 3 3 3
 :gutter: 1 1 1 2
 
 :::{grid-item-card} Flask
 :link: flask
 :link-type: doc
+
+Discover to run Panel applications alongside an existing Flask server.
 :::
 
 :::{grid-item-card} FastAPI
 :link: FastAPI
 :link-type: doc
+
+Discover to run Panel applications alongside an existing FastAPI server. 
 :::
 
 :::{grid-item-card} Django
-:link: django
+:link: Django
 :link-type: doc
+
+Discover to run Panel applications on a Django server (replacing the standard Tornado based server).
 :::
 
 ::::
@@ -29,5 +35,5 @@ These guides will cover how to integrate Panel applications with various externa
 
 flask
 FastAPI
-django
+Django
 ```
diff --git a/doc/how_to/state/busy.md b/doc/how_to/state/busy.md
new file mode 100644
index 0000000000..0400a71ab6
--- /dev/null
+++ b/doc/how_to/state/busy.md
@@ -0,0 +1,23 @@
+# Busyness state
+
+Often an application will have longer running callbacks which are being processed on the server, to give users some indication that the server is busy you may therefore have some way of indicating that busy state. The `pn.state.busy` parameter indicates whether a callback is being actively processed and may be linked to some visual indicator.
+
+Below we will create a little application to demonstrate this, we will create a button which executes some longer running task on click and then create an indicator function that displays `'I'm busy'` when the `pn.state.busy` parameter is `True` and `'I'm idle'` when it is not:
+
+```{pyodide}
+import time
+
+def processing(event):
+    # Some longer running task
+    time.sleep(1)
+    
+button = pn.widgets.Button(name='Click me!')
+button.on_click(processing)
+
+def indicator(busy):
+    return "I'm busy" if busy else "I'm idle"
+
+pn.Row(button, pn.bind(indicator, pn.state.param.busy))
+```
+
+This way we can create a global indicator for the busy state instead of modifying all our callbacks.
\ No newline at end of file
diff --git a/doc/how_to/state/index.md b/doc/how_to/state/index.md
new file mode 100644
index 0000000000..9db6b92e90
--- /dev/null
+++ b/doc/how_to/state/index.md
@@ -0,0 +1,39 @@
+# Accessing session state
+
+Whenever a Panel application is being served the `panel.state` object will provide a variety of information about the current user session including the HTTP request that initiated the session, information about the browser and the current URL and more. 
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` HTTP Request
+:link: manual
+:link-type: doc
+
+How to access information about the HTTP request associated with a session.
+:::
+
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` url
+:link: url
+:link-type: doc
+
+How to access and manipulate the URL.
+:::
+
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` busy
+:link: busy
+:link-type: doc
+
+How to access the busy state.
+:::
+
+::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+request
+url
+busy
+```
\ No newline at end of file
diff --git a/doc/how_to/state/request.md b/doc/how_to/state/request.md
new file mode 100644
index 0000000000..15df1988f7
--- /dev/null
+++ b/doc/how_to/state/request.md
@@ -0,0 +1,24 @@
+# Access HTTP request state
+
+The `panel.state` object holds a wide range of information about the HTTP request that is associated with a running session. Note that if you are running Panel inside a notebook session these attributes will simply return `None`.
+
+## Request arguments
+
+The request arguments are made available to be accessed on ``pn.state.session_args``. For example if your application is hosted at ``localhost:8001/app``, appending ``?phase=0.5`` to the URL will allow you to access the phase variable using the following code:
+
+```python
+try:
+    phase = int(pn.state.session_args.get('phase')[0])
+except Exception:
+    phase = 1
+```
+
+This mechanism may be used to modify the behavior of an app dependending on parameters provided in the URL. 
+
+## Cookies
+
+The `panel.state.cookies` will allow accessing the cookies stored in the browser and on the bokeh server.
+
+## Headers
+
+The `panel.state.headers` will allow accessing the HTTP headers stored in the browser and on the bokeh server.
diff --git a/doc/how_to/state/url.md b/doc/how_to/state/url.md
new file mode 100644
index 0000000000..c1c5a14ce2
--- /dev/null
+++ b/doc/how_to/state/url.md
@@ -0,0 +1,55 @@
+# Accessing and manipulating the URL
+
+## Accessing
+
+When starting a server session Panel will attach a `Location` component which can be accessed using `pn.state.location`. The `Location` component servers a number of functions:
+
+- Navigation between pages via ``pathname``
+- Sharing (parts of) the page state in the url as ``search`` parameters for bookmarking and sharing.
+- Navigating to subsections of the page via the ``hash_`` parameter.
+
+### Core
+
+* **``pathname``** (string): pathname part of the url, e.g. '/user_guide/Interact.html'.
+* **``search``** (string): search part of the url e.g. '?color=blue'.
+* **``hash_``** (string): hash part of the url e.g. '#interact'.
+* **``reload``** (bool): Whether or not to reload the page when the url is updated.
+    - For independent apps this should be set to True. 
+    - For integrated or single page apps this should be set to False.
+
+### Readonly
+
+* **``href``** (string): The full url, e.g. 'https://panel.holoviz.org/user_guide/Interact.html:80?color=blue#interact'.
+* **``protocol``** (string): protocol part of the url, e.g. 'http:' or 'https:'
+* **``port``** (string): port number, e.g. '80'
+
+## Manipulating
+
+By default the current [query parameters](https://en.wikipedia.org/wiki/Query_string) in the URL (specified as a URL suffix such as `?color=blue`) are made available on `pn.state.location.query_params`. To make working with query parameters straightforward the `Location` object also provides a `sync` method which allows syncing query parameters with the parameters on a `Parameterized` object.
+
+We will start by defining a `Parameterized` class:
+
+```{pyodide}
+import param
+import panel as pn
+
+class QueryExample(param.Parameterized):
+    
+    integer = param.Integer(default=None, bounds=(0, 10))
+    
+    string = param.String(default='A string')
+```
+
+Now we will use the `pn.state.location` object to sync it with the URL query string (note that in a notebook environment `pn.state.location` is not initialized until the first plot has been displayed). The sync method takes the Parameterized object or instance to sync with as the first argument and a list or dictionary of the parameters as the second argument. If a dictionary is provided it should map from the Parameterized object's parameters to the query parameter name in the URL:
+
+```{pyodide}
+pn.state.location.sync(QueryExample, {'integer': 'int', 'string': 'str'})
+```
+
+Now the Parameterized object is bi-directionally linked to the URL query parameter, if we set a query parameter in Python it will update the URL bar and when we specify a URL with a query parameter that will be set on the Parameterized, e.g. let us set the 'integer' parameter and watch the URL in your browser update:
+
+```{pyodide}
+QueryExample.integer = 5
+```
+
+Note to unsync the Parameterized object you can simply call `pn.state.location.unsync(QueryExample)`.
diff --git a/doc/how_to/wasm/convert.md b/doc/how_to/wasm/convert.md
new file mode 100644
index 0000000000..79d5a38839
--- /dev/null
+++ b/doc/how_to/wasm/convert.md
@@ -0,0 +1,125 @@
+# Converting Panel applications
+
+Writing an HTML file from scratch with all the Javascript and Python dependencies and other boilerplate can be quite cumbersome, and requires learning a good bit of HTML. To avoid writing all the boilerplate, Panel provides support for converting an entire application (including Panel templates) to an HTML file, using the `panel convert` command-line interface (CLI). As a starting point create one or more Python scripts or notebook files containing your application. The only requirement is that they import only global modules and packages (relative imports of other scripts or modules is not supported) and that the libraries have been [compiled for Pyodide](https://github.com/pyodide/pyodide/tree/main/packages) or are available as pure-Python wheels from PyPI.
+
+The ``panel convert`` command has the following options:
+
+    positional arguments:
+      SCRIPTs               The scripts or notebooks to convert
+
+    optional arguments:
+      -h, --help            Show this help message and exit
+      --to                  The format to convert to, one of 'pyodide', 'pyodide-worker' or 'pyscript'
+      --out                 Directory to export files to
+      --title               Custom title for the application(s)
+      --skip-embed          Whether to skip the prerendering while pyodide loads.
+      --index               Whether to create an index if multiple files are served.
+      --pwa                 Whether to add files to allow serving the application as a Progressive Web App.
+      --requirements        List of Python requirements to add to the converted file. By default it will automatically try to infer dependencies based on your imports and Panel will automatically be included.
+      --watch               Watches files for changes and rebuilds them when they are updated.
+      --disable-http-patch  Disables patching of http requests using pyodide-http library.
+
+## Example
+
+This example will demonstrate how to *convert* and *serve* a basic data app locally.
+
+- Create a `script.py` file with the following content
+
+```python
+import panel as pn
+
+from sklearn.datasets import load_iris
+from sklearn.metrics import accuracy_score
+from xgboost import XGBClassifier
+
+pn.extension(sizing_mode="stretch_width", template="fast")
+pn.state.template.param.update(site="Panel in the Browser", title="XGBoost Example")
+
+iris_df = load_iris(as_frame=True)
+
+trees = pn.widgets.IntSlider(start=2, end=30, name="Number of trees")
+
+def pipeline(trees):
+    model = XGBClassifier(max_depth=2, n_estimators=trees)
+    model.fit(iris_df.data, iris_df.target)
+    accuracy = round(accuracy_score(iris_df.target, model.predict(iris_df.data)) * 100, 1)
+    return pn.indicators.Number(
+        name="Test score",
+        value=accuracy,
+        format="{value}%",
+        colors=[(97.5, "red"), (99.0, "orange"), (100, "green")],
+    )
+
+pn.Column(
+    "Simple example of training an XGBoost classification model on the small Iris dataset.",
+    iris_df.data.head(),
+    "Move the slider below to change the number of training rounds for the XGBoost classifier. The training accuracy score will adjust accordingly.",
+    trees,
+    pn.bind(pipeline, trees),
+).servable()
+```
+
+- Run `panel convert script.py --to pyodide-worker --out pyodide`
+- Run `python3 -m http.server` to start a web server locally
+- Open `http://localhost:8000/pyodide/script.html` to try out the app.
+
+The app should look like this
+
+![Panel in the browser](../../_static/images/pyodide_xgboost_app.png)
+
+You can now add the `script.html` (and `script.js` file if you used the `pyodide-worker` target) to your Github pages or similar. **no separate server needed!**
+
+## Tips & Tricks for development
+
+- While developing you should run the script locally with *auto reload*: `panel serve script.py --autoreload`.
+- You can also watch your script for changes and rebuild it if you make an edit with `panel convert ... --watch`
+- If the converted app does not work as expected, you can most often find the errors in the browser
+console. [This guide](https://balsamiq.com/support/faqs/browserconsole/) describes how to open the
+console.
+- You can find answers to the most frequently asked questions about *Python in the browser* in the [Pyodide - FAQ](https://pyodide.org/en/stable/usage/faq.html) or the [PyScript FAQ](https://docs.pyscript.net/latest/reference/faq.html). For example the answer to "How can I load external data?".
+
+## Formats
+
+Using the `--to` argument on the CLI you can control the format of the file that is generated by `panel convert`. You have three options, each with distinct advantages and disadvantages:
+
+- **`pyodide`** (default): Run application using Pyodide running in the main thread. This option is less performant than pyodide-worker but produces completely standalone HTML files that do not have to be hosted on a static file server (e.g. Github Pages).
+- **`pyodide-worker`**: Generates an HTML file and a JS file containing a Web Worker that runs in a separate thread. This is the most performant option, but files have to be hosted on a static file server.
+- **`pyscript`**: Generates an HTML leveraging PyScript. This produces standalone HTML files containing `<py-env>` and `<py-script>` tags containing the dependencies and the application code. This output is the most readable, and should have equivalent performance to the `pyodide` option.
+
+## Requirements
+
+The `panel convert` command will try its best to figure out the requirements of your script based on the imports, which means that in most cases you won't have to provide the explicit `--requirements` argument. However, if some library uses an optional import that cannot be inferred from the list of imports in your app you will have to provide an explicit list of dependencies. Note that `panel` and its dependencies including NumPy and Bokeh will be added loaded automatically, e.g. the explicit requirements for the app above would look like this:
+
+```bash
+panel convert script.py --to pyodide-worker --out pyodide --requirements xgboost scikit-learn pandas
+```
+
+Alternatively you may also provide a `requirements.txt` file:
+
+```bash
+panel convert script.py --to pyodide-worker --out pyodide --requirements requirements.txt
+```
+
+## Index
+
+If you convert multiple applications at once you may want to add an index to be able to navigate between the applications easily. To enable the index simply pass `--index` to the convert command.
+
+## Prerendering
+
+In order to improve the loading experience Panel will pre-render and embed the initial render of the page and replace it with live components once the page is loaded. This is important because Pyodide has to fetch the entire Python runtime and all required packages from a CDN. This can be **very** slow depending on your internet connection. If you want to disable this behavior and render an initially blank page use the `--skip-embed` option. Otherwise Panel will render application using the current Python process (presumably outside the browser) into the HTML file as a "cached" copy of the application for the user to see while the Python runtime is initialized and the actual browser-generated application is ready for interaction.
+
+## Progressive Web Apps
+
+Progressive web applications (PWAs) provide a way for your web apps to behave almost like a native application, both on mobile devices and on the desktop. The `panel convert` CLI has a `--pwa` option that will generate the necessary files to turn your Panel + Pyodide application into a PWA. The web manifest, service worker script and assets such as thumbnails are exported alongside the other HTML and JS files and can then be hosted on your static file host. Note that Progressive web apps must be served via HTTPS to ensure user privacy, security, and content authenticity, including the application itself and all resources it references. Depending on your hosting service, you will have to enable HTTPS yourself. GitHub pages generally make this very simple and provide a great starting point.
+
+Once generated, you can inspect the `site.webmanifest` file and modify it to your liking, including updating the favicons in the assets directory.
+
+```{note}
+If you decide to enable the `--pwa` ensure that you also provide a unique `--title`. Otherwise the browser caches storing your apps dependencies will end up overwriting each other.
+```
+
+## Handling HTTP requests
+
+By default Panel 0.14.1 will install the [pyodide-http](https://github.com/koenvo/pyodide-http) library which patches `urllib3` and `requests` making it possible to use them within the pyodide process. To disable this behavior use the `--disable-http-patch` CLI option.
+
+Note that making HTTP requests when converting to the `pyodide` or `pyscript` target will block the main browser thread and result in a poor user experience. Therefore we strongly recommend converting to `pyodide-worker` if your app is making synchronous HTTP requests.
diff --git a/doc/how_to/wasm/index.md b/doc/how_to/wasm/index.md
new file mode 100644
index 0000000000..d754ffc8a4
--- /dev/null
+++ b/doc/how_to/wasm/index.md
@@ -0,0 +1,60 @@
+# Running Panel in the Browser with WASM
+
+Panel lets you write dashboards and other applications in Python that are accessed using a web browser. Typically, the Python interpreter runs as a separate Jupyter or Bokeh server process, communicating with JavaScript code running in the client browser. However, **it is now possible to run Python directly in the browser**, with **no separate server needed!**
+
+The underlying technology involved is called [WebAssembly](https://webassembly.org/) (or WASM). More specifically, [Pyodide](https://pyodide.org/) pioneered the ability to install Python libraries, manipulate the web page's [DOM](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Introduction) from Python, and execute regular Python code entirely in the browser. A number of libraries have sprung up around Python in WASM, including [PyScript](https://pyscript.net/).
+
+Panel can be run directly in Pyodide and has special support for rendering in PyScript.
+
+This guide will take you through the process of either
+
+- Automatically converting Panel applications into a Pyodide/PyScript based application
+- Manually installing Panel in the browser and using it to render components.
+- Embedding Panel in your Sphinx documentation.
+- Setting up a Jupyterlite instance with support for Panel
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`duplicate;2.5em;sd-mr-1` Convert to WASM.
+:link: convert
+:link-type: doc
+
+Discover how to convert existing Panel applications to WASM.
+:::
+
+:::{grid-item-card} {octicon}`code;2.5em;sd-mr-1` Use from WASM
+:link: standalone
+:link-type: doc
+
+Discover how to set up and use Panel from Pyodide and PyScript.
+:::
+
+:::{grid-item-card} {octicon}`book;2.5em;sd-mr-1` Sphinx Integration
+:link: user_info
+:link-type: doc
+
+Discover how to integrate live Panel components in your Sphinx based documentation. 
+:::
+
+:::{grid-item-card} {octicon}`zap;2.5em;sd-mr-1` JupyterLite
+:link: jupyterlite
+:link-type: doc
+
+Discover how to set up a JupyterLite deployment capable of rendering interactive Panel output. 
+:::
+
+::::
+
+Note that since Panel is built on Bokeh server and Tornado it is also possible to implement your own authentication independent of the OAuth components shipped with Panel, [see the Bokeh documentation](https://docs.bokeh.org/en/latest/docs/user_guide/server.html#authentication) for further information.
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+convert
+standalone
+sphinx
+jupyterlite
+```
diff --git a/doc/how_to/wasm/jupyterlite.md b/doc/how_to/wasm/jupyterlite.md
new file mode 100644
index 0000000000..5cf8dff23a
--- /dev/null
+++ b/doc/how_to/wasm/jupyterlite.md
@@ -0,0 +1,24 @@
+# Setting up JupyterLite
+
+[JupyterLite](https://jupyterlite.readthedocs.io/en/latest/) is a JupyterLab distribution built from all the usual components and extensions that come with JupyterLab, but now running entirely in the browser with no external server needed. In order to use Panel in JupyterLite you will have to build your own distribution. As a starting point we recommend [this guide](https://jupyterlite.readthedocs.io/en/latest/howto/configure/simple_extensions.html) in the JupyterLite documentation, which will tell you how to set up an environment to begin building JupyterLite.
+
+## Create a `<lite-dir>`
+
+Once your environment is set up, create a new directory, which will become the source for your JupyterLite distribution. Once created place the file contents you want to make available in JupyterLite into `<lite-dir>/files`.
+
+## Adding extensions
+
+In order for Panel to set up communication channels inside JupyterLite we have to add the `pyviz_comms` extension to the environment. Ensure this package is installed in the environment you are building Panel from, e.g. by running `pip install pyviz_comms` OR by including it in the `requirements.txt` you used when setting up your build environment.
+
+## Optimized wheels (optional)
+
+To get Panel installed inside a Jupyterlite session we have to install it with `piplite`. The default Bokeh and Panel packages are quite large since they contain contents which are needed in a server environment. Since we will be running inside Jupyter these contents are not needed. To bundle the optimized packages download them from the CDN and place them in the `<lite-dir>/pypi` directory. You can download them from the CDN (replacing the latest version numbers):
+
+```
+https://cdn.holoviz.org/panel/0.14.2/dist/wheels/bokeh-2.4.3-py3-none-any.whl
+https://cdn.holoviz.org/panel/0.14.2/dist/wheels/panel-0.14.2-py3-none-any.whl
+```
+
+## Building Panel lite
+
+Finally `cd` into your `<lite-dir>` and run `jupyter lite build --output-dir ./dist`. This will bundle up the file contents, extensions and wheels into your JupyterLite distribution. You can now easily deploy this to [GitHub pages](https://jupyterlite.readthedocs.io/en/latest/quickstart/deploy.html) or elsewhere.
diff --git a/doc/how_to/wasm/sphinx.md b/doc/how_to/wasm/sphinx.md
new file mode 100644
index 0000000000..f3a0cea786
--- /dev/null
+++ b/doc/how_to/wasm/sphinx.md
@@ -0,0 +1,122 @@
+# Embedding in Sphinx documentation
+
+One more option is to include live Panel examples in your Sphinx documentation using the `nbsite.pyodide` directive.
+
+## Setup
+
+In the near future we hope to make this a separate Sphinx extension, until then simply install latest nbsite with `pip` or `conda`:
+
+::::{tab-set}
+:::{tab-item} Conda
+:sync: conda
+
+``` bash
+conda install -c pyviz nbsite
+```
+
+:::
+:::{tab-item} Pip
+:sync: pip
+
+``` bash
+pip install nbsite
+```
+:::
+::::
+
+add the extension to the Sphinx `conf.py`:
+
+```python
+extensions += [
+    ...,
+    'nbsite.pyodide'
+]
+```
+
+## Configuration
+
+In the `conf.py` of your project you can configure the extension in a number of ways by defining an `nbsite_pyodide_conf` dictionary with the following options:
+
+- `PYODIDE_URL`: The URl to fetch Pyodide from
+- `autodetect_deps` (default=`True`): Whether to automatically detect dependencies in the executed code and install them.
+- `enable_pwa` (default=`True`): Whether to add a web manifest and service worker to configure the documentation as a progressive web app.
+- `requirements` (default=`['panel']`): Default requirements to include (by default this includes just panel.
+- `scripts`: Scripts to add to the website when a Pyodide cell is first executed.
+- `setup_code` (default=`''`): Python code to run when initializing the Pyodide runtime.
+
+and then you can use the `pyodide` as an RST directive:
+
+```rst
+.. pyodide::
+
+   import panel as pn
+
+   slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
+
+   def callback(new):
+       return f'Amplitude is: {new}'
+
+   pn.Row(slider, pn.bind(callback, slider))
+```
+
+## Examples
+
+The resulting output looks like this:
+
+```{pyodide}
+import panel as pn
+```
+
+
+```{pyodide}
+slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
+
+def callback(new):
+    return f'Amplitude is: {new}'
+
+pn.Row(slider, pn.bind(callback, slider))
+```
+
+In addition to rendering Panel components it also renders regular Pytho
+types:
+
+```{pyodide}
+1+1
+```
+
+
+```{pyodide}
+"A string"
+```
+
+and also handles stdout and stderr streams:
+
+```{pyodide}
+import numpy as np
+for i in range(10):
+    print(f'Repeat {i}')
+    for i in range(10000):
+        np.random.rand(1000)
+```
+
+```{pyodide}
+raise ValueError('Encountered an error')
+```
+
+and supports `_repr_<mime>_` methods that are commonly used by the IPython and Jupyter ecosystem:
+
+```{pyodide}
+class HTML:
+
+    def __init__(self, html):
+	    self.html = html
+
+    def _repr_html_(self):
+	    return self.html
+
+HTML('<b>HTML!</b>')
+```
+
+## Usage
+
+The code cell will display a button to execute the cell, which will warn about downloading the Python runtime on first-click and ask you to confirm whether you want to proceed. It will then download Pyodide, all required packages and finally display the output.
diff --git a/doc/how_to/wasm/standalone.md b/doc/how_to/wasm/standalone.md
new file mode 100644
index 0000000000..af64e74d68
--- /dev/null
+++ b/doc/how_to/wasm/standalone.md
@@ -0,0 +1,144 @@
+# Using Panel in Pyodide & PyScript
+
+## Installing Panel in the browser
+
+To install Panel in the browser you merely have to use the installation mechanism provided by each supported runtime:
+
+### Pyodide
+
+Currently the best supported mechanism for installing packages in Pyodide is `micropip`.
+
+To get started with Pyodide simply follow their [Getting started guide](https://pyodide.org/en/stable/usage/quickstart.html). Note that if you want to render Panel output you will also have to load [Bokeh.js](https://docs.bokeh.org/en/2.4.1/docs/first_steps/installation.html#install-bokehjs:~:text=Installing%20standalone%20BokehJS%C2%B6) and Panel.js from CDN. The most basic pyodide application therefore looks like this:
+
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <script src="https://cdn.jsdelivr.net/pyodide/v0.21.2/full/pyodide.js"></script>
+
+    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.js"></script>
+    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js"></script>
+    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js"></script>
+    <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/@holoviz/panel@0.14.0/dist/panel.min.js"></script>
+
+  </head>
+  <body>
+    <div id="simple_app"></div>
+    <script type="text/javascript">
+      async function main(){
+        let pyodide = await loadPyodide();
+        await pyodide.loadPackage("micropip");
+        const micropip = pyodide.pyimport("micropip");
+        await micropip.install('panel')
+        pyodide.runPython(`
+          import panel as pn
+
+          pn.extension(sizing_mode="stretch_width")
+
+          slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
+
+          def callback(new):
+              return f'Amplitude is: {new}'
+
+          pn.Row(slider, pn.bind(callback, slider)).servable(target='simple_app');
+	    `);
+      }
+      main();
+    </script>
+  </body>
+</html>
+```
+
+The app should look like this
+
+![Panel Pyodide App](../_static/images/pyodide_app_simple.png)
+
+:::{admonition}
+The default bokeh and panel packages are very large, therefore we recommend you pip install specialized wheels:
+
+```javascript
+const bk_whl = "https://cdn.holoviz.org/panel/0.14.0/wheels/bokeh-2.4.3-py3-none-any.whl"
+const pn_whl = "https://cdn.holoviz.org/panel/0.14.0/wheels/panel-0.14.0-py3-none-any.whl"
+await micropip.install(bk_whl, pn_whl)
+```
+:::
+
+### PyScript
+
+PyScript makes it even easier to manage your dependencies, with a `<py-config>` HTML tag. Simply include `panel` in the list of dependencies and PyScript will install it automatically:
+
+```html
+<py-config>
+packages = [
+  "panel",
+  ...
+]
+</py-config>
+```
+
+Once installed you will be able to `import panel` in your `<py-script>` tag. Again, make sure you also load Bokeh.js and Panel.js:
+
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.js"></script>
+    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js"></script>
+    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js"></script>
+    <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/@holoviz/panel@0.14.0/dist/panel.min.js"></script>
+
+    <link rel="stylesheet" href="https://pyscript.net/releases/2022.09.1/pyscript.css" />
+    <script defer src="https://pyscript.net/releases/2022.09.1/pyscript.js"></script>
+  </head>
+  <body>
+    <py-config>
+       packages = [
+         "panel",
+         ...
+       ]
+    </py-config>
+    <div id="simple_app"></div>
+    <py-script>
+      import panel as pn
+
+      pn.extension(sizing_mode="stretch_width")
+
+      slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
+
+      def callback(new):
+         return f'Amplitude is: {new}'
+
+      pn.Row(slider, pn.bind(callback, slider)).servable(target='simple_app');
+    </py-script>
+  </body>
+</html>
+```
+
+The app should look identical to the one above but show a loading spinner while Pyodide is initializing.
+
+## Rendering Panel components in Pyodide or Pyscript
+
+Rendering Panel components into the DOM is quite straightforward. You can simply use the `.servable()` method on any component and provide a target that should match the `id` of a DOM node:
+
+```python
+import panel as pn
+
+slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
+
+def callback(new):
+    return f'Amplitude is: {new}'
+
+pn.Row(slider, pn.bind(callback, slider)).servable(target='simple_app');
+```
+
+This code will render this simple application into the `simple_app` DOM node:
+
+```html
+<div id="simple_app"></div>
+```
+
+Alternatively you can also use the `panel.io.pyodide.write` function to write into a particular DOM node:
+
+```python
+await pn.io.pyodide.write('simple_app', component)
+```
diff --git a/doc/user_guide/Authentication.md b/doc/user_guide/Authentication.md
deleted file mode 100644
index a5906bbe3e..0000000000
--- a/doc/user_guide/Authentication.md
+++ /dev/null
@@ -1,218 +0,0 @@
-# Authentication
-
-Authentication is a difficult topic fraught with potential pitfalls and complicated configuration options. Panel aims to be a "batteries-included" package for building applications and dashboards and therefore ships with a number of inbuilt providers for authentication in an application.
-
-The primary mechanism by which Panel performs autentication is [OAuth 2.0](https://oauth.net/2/). The official specification for OAuth 2.0 describes the protocol as follows:
-
-    The OAuth 2.0 authorization framework enables a third-party
-    application to obtain limited access to an HTTP service, either on
-    behalf of a resource owner by orchestrating an approval interaction
-    between the resource owner and the HTTP service, or by allowing the
-    third-party application to obtain access on its own behalf.
-
-In other words OAuth outsources authentication to a third party provider, e.g. GitHub, Google or Azure AD, to authenticate the user credentials and give limited access to the APIs of that service.
-
-Note that since Panel is built on Bokeh server and Tornado it is also possible to implement your own authentication independent of the OAuth components shipped with Panel, [see the Bokeh documentation](https://docs.bokeh.org/en/latest/docs/user_guide/server.html#authentication) for further information.
-
-## Configuring OAuth
-
-The OAuth component will stop any user from accessing the application before first logging into the selected provider. The configuration to set up OAuth is all handled via the global `pn.config` object, which has a number of OAuth related parameters. When launching the application via the `panel serve` CLI command these config options can be set as CLI arguments or environment variables, when using the `pn.serve` function on the other hand these variables can be passed in as arguments.
-
-### `oauth_provider`
-
-The first step in configuring a OAuth is to specify a specific OAuth provider. Panel ships with a number of providers by default:
-
-* `azure`: Azure Active Directory
-* `bitbucket`: Bitbucket
-* `github`: GitHub
-* `gitlab`: GitLab
-* `google`: Google
-* `okta`: Okta
-
-We will go through the process of configuring each of these individually later but for now all we need to know that the `oauth_provider` can be set on the commandline using the `--oauth-provider` CLI argument to `panel serve` or the `PANEL_OAUTH_PROVIDER` environment variable.
-
-Examples:
-
-```
-panel serve oauth_example.py --oauth-provider=...
-
-PANEL_OAUTH_PROVIDER=... panel serve oauth_example.py
-```
-
-### `oauth_key` and `oauth_secret`
-
-To authenticate with a OAuth provider we generally require two pieces of information (although some providers will require more customization):
-
-1. The Client ID is a public identifier for apps.
-2. The Client Secret is a secret known only to the application and the authorization server.
-
-These can be configured in a number of ways the client ID and client secret can be supplied to the `panel serve` command as `--oauth-key` and `--oauth-secret` CLI arguments or `PANEL_OAUTH_KEY` and `PANEL_OAUTH_SECRET` environment variables respectively.
-
-Examples:
-
-```
-panel serve oauth_example.py --oauth-key=... --oauth-secret=...
-
-PANEL_OAUTH_KEY=... PANEL_OAUTH_KEY=... panel serve oauth_example.py ...
-```
-
-### `oauth_extra_params`
-
-Some OAuth providers will require some additional configuration options which will become part of the OAuth URLs. The `oauth_extra_params` configuration variable allows providing this additional information and can be set using the `--oauth-extra-params` CLI argument or `PANEL_OAUTH_EXTRA_PARAMS`.
-
-Examples:
-
-```
-panel serve oauth_example.py --oauth-extra-params={'tenant_id': ...}
-
-PANEL_OAUTH_EXTRA_PARAMS={'tenant_id': ...} panel serve oauth_example.py ...
-```
-
-### `cookie_secret`
-
-Once authenticated the user information and authorization token will be set as secure cookies. Cookies are not secure and can easily be modified by clients. A secure cookie ensures that the user information cannot be interfered with or forged by the client by signing it with a secret key. Note that secure cookies guarantee integrity but not confidentiality. That is, the cookie cannot be modified but its contents can be seen by the user. To generate a `cookie_secret` use the `panel secret` CLI argument or generate some other random non-guessable string, ideally with at least 256-bits of entropy.
-
-To set the `cookie_secret` supply `--cookie-secret` as a CLI argument or set the `PANEL_COOKIE_SECRET` environment variable.
-
-Examples:
-
-```
-panel serve oauth_example.py --cookie-secret=...
-
-PANEL_COOKIE_SECRET=... panel serve oauth_example.py ...
-```
-
-### `oauth_expiry`
-
-The OAuth expiry configuration value determines for how long an OAuth token will be valid once it has been issued. By default it is valid for 1 day, but may be overwritten by providing the duration in the number of days (decimal values are allowed).
-
-To set the `oauth_expiry` supply `--oauth-expiry-days` as a CLI argument or set the `PANEL_OAUTH_EXPIRY` environment variable.
-
-Examples:
-
-```
-panel serve oauth_example.py --oauth-expiry-days=...
-
-PANEL_OAUTH_EXPIRY=... panel serve oauth_example.py ...
-```
-
-### Encryption
-
-The architecture of the Bokeh/Panel server means that credentials stored as cookies can be leak in a number of ways. On the initial HTTP(S) request the server will respond with the HTML document that renders the application and this will include an unencrypted token containing the OAuth information. To ensure that the user information and access token are properly encrypted we rely on the Fernet encryption in the `cryptography` library. You can install it with `pip install cryptography` or `conda install cryptography`.
-
-Once installed you will be able to generate a encryption key with `panel oauth-secret`. This will generate a secret you can pass to the `panel serve` CLI command using the ``--oauth-encryption-key`` argument or `PANEL_OAUTH_ENCRYPTION` environment variable.
-
-Examples:
-
-```
-panel serve oauth_example.py --oauth-encryption-key=...
-
-PANEL_OAUTH_ENCRYPTION=... panel serve oauth_example.py ...
-```
-
-### Redirect URI
-
-Once the OAuth provider has authenticated a user it has to redirect them back to the application, this is what is known as the redirect URI. For security reasons this has to match the URL registered with the OAuth provider exactly. By default Panel will redirect the user straight back to the original URL of your app, e.g. when you're hosting your app at `https://myapp.myprovider.com` Panel will use that as the redirect URI. However in certain scenarios you may override this to provide a specific redirect URI. This can be achieved with the `--oauth-redirect-uri` CLI argument or the `PANEL_OAUTH_REDIRECT_URI` environment variable.
-
-Examples:
-
-```
-panel serve oauth_example.py --oauth-redirect-uri=...
-
-PANEL_OAUTH_REDIRECT_URI=... panel serve oauth_example.py
-```
-
-### Summary
-
-A fully configured OAuth configuration may look like this:
-
-```
-panel serve oauth_example.py --oauth-provider=github --oauth-key=... --oauth-secret=... --cookie-secret=... --oauth-encryption-key=...
-
-PANEL_OAUTH_PROVIDER=... PANEL_OAUTH_KEY=... PANEL_OAUTH_SECRET=... PANEL_COOKIE_SECRET=... PANEL_OAUTH_ENCRYPTION=... panel serve oauth_example.py ...`
-```
-
-## Accessing OAuth information
-
-Once a user is authorized with the chosen OAuth provider certain user information and an `access_token` will be available to be used in the application to customize the user experience. Like all other global state this may be accessed on the `pn.state` object, specifically it makes three attributes available:
-
-* **`pn.state.user`**: A unique name, email or ID that identifies the user.
-* **`pn.state.access_token`**: The access token issued by the OAuth provider to authorize requests to its APIs.
-* **`pn.state.refresh_token`**: The refresh token issued by the OAuth provider to authorize requests to its APIs (if available these are usually longer lived than the `access_token`).
-* **`pn.state.user_info`**: Additional user information provided by the OAuth provider. This may include names, email, APIs to request further user information, IDs and more.
-
-## Authorization
-
-The OAuth providers integrated with Panel provide an easy way to enable authentication on your applications. This verifies the identity of a user and also provides some level of access control (i.e. authorization). However often times the OAuth configuration is controlled by a corporate IT department or is otherwise difficult to manage so its often easier to grant permissions to use the OAuth provider freely but then restrict access controls in the application itself. To manage access you can provide an `authorization_callback` as part of your applications.
-
-The `authorization_callback` can be configured on `pn.config` or via the `pn.extension`:
-
-```python
-import panel as pn
-
-def authorize(user_info):
-    with open('users.txt') as f:
-        valid_users = f.readlines()
-    return user_info['username'] in valid_users
-
-pn.config.authorize_callback = authorize # or pn.extension(..., authorize_callback=authorize)
-```
-
-The `authorize_callback` is given a dictionary containing the data in the OAuth provider's `id_token`. The example above checks whether the current user is in the list of users specified in a `user.txt` file. However you can implement whatever logic you want to either grant a user access or reject it.
-
-If a user is not authorized they will be presented with a authorization error template which can be configured using the `--auth-template` commandline option or by setting `config.auth_template`.
-
-<img src="../_static/authorization.png" width="600" style="margin-left: auto; margin-right: auto; display: block;"></img>
-
-The auth template must be a valid Jinja2 template and accepts a number of arguments:
-
-- `{{ title }}`: The page title.
-- `{{ error_type }}`: The type of error.
-- `{{ error }}`: A short description of the error.
-- `{{ error_msg }}`: A full description of the error.
-
-## OAuth Providers
-
-Panel provides a  number of inbuilt OAuth providers, below is the list
-
-### **Azure Active Directory**
-
-To set up OAuth2.0 authentication for Azure Active directory follow [these instructions](https://docs.microsoft.com/en-us/azure/api-management/api-management-howto-protect-backend-with-aad). In addition to the `oauth_key` and `oauth_secret` ensure that you also supply the tenant ID using `oauth_extra_params`, e.g.:
-
-```
-panel serve oauth_test.py --oauth-extra-params="{'tenant': '...'}"
-
-PANEL_OAUTH_EXTRA_PARAMS="{'tenant': '...'}" panel serve oauth_example.py ...
-```
-
-### **Bitbucket**
-
-Bitbucket provides instructions about setting [setting up an OAuth consumer](https://support.atlassian.com/bitbucket-cloud/docs/use-oauth-on-bitbucket-cloud/). Follow these and then supply the `oauth_key` and `oauth_secret` to Panel as described above.
-
-### **GitHub**
-
-GitHub provides detailed instructions on [creating an OAuth app](https://developer.github.com/apps/building-oauth-apps/creating-an-oauth-app/). Follow these and then supply the `oauth_key` and `oauth_secret` to Panel as described above.
-
-### **GitLab**
-
-GitLab provides a detailed guide on [configuring an OAuth](https://docs.gitlab.com/ee/api/oauth2.html) application. In addition to the `oauth_key` and `oauth_secret` you will also have to supply a custom url using the `oauth_extra_params` if you have a custom GitLab instance (the default `oauth_extra_params={'url': 'gitlab.com'}`).
-
-### **Google**
-
-Google provides a guide about [configuring a OAuth application](https://developers.google.com/identity/protocols/oauth2/native-app). By default nothing except the `oauth_key` and `oauth_secret` are required but to access Google services you may also want to override the default `scope` via the `oauth_extra_params`.
-
-### **Okta**
-
-Okta provides a guide about [configuring OAuth2](https://developer.okta.com/docs/concepts/oauth-openid/). You must provide an `oauth_key` and `oauth_secret` but in most other ordinary setups you will also have to provide a `url` via the `oauth_extra_params` and if you have set up a custom authentication server (i.e. not 'default') with Okta you must also provide 'server', the `oauth_extra_params` should then look something like this: `{'server': 'custom', 'url': 'dev-***.okta.com'}`
-
-### Plugins
-
-The Panel OAuth providers are pluggable, in other words downstream libraries may define their own Tornado `RequestHandler` to be used with Panel. To register such a component the `setup.py` of the downstream package should register an entry_point that Panel can discover. To read more about entry points see the [Python documentation](https://packaging.python.org/specifications/entry-points/). A custom OAuth request handler in your library may be registered as follows:
-
-```python
-entry_points={
-    'panel.auth': [
-        "custom = my_library.auth:MyCustomOAuthRequestHandler"
-    ]
-}
-```
diff --git a/doc/user_guide/Running_in_Webassembly.md b/doc/user_guide/Running_in_Webassembly.md
deleted file mode 100644
index 83d9635e5f..0000000000
--- a/doc/user_guide/Running_in_Webassembly.md
+++ /dev/null
@@ -1,431 +0,0 @@
-# Running Panel in the Browser with WASM
-
-Panel lets you write dashboards and other applications in Python that are accessed using a web browser. Typically, the Python interpreter runs as a separate Jupyter or Bokeh server process, communicating with JavaScript code running in the client browser. However, **it is now possible to run Python directly in the browser**, with **no separate server needed!**
-
-The underlying technology involved is called [WebAssembly](https://webassembly.org/) (or WASM). More specifically, [Pyodide](https://pyodide.org/) pioneered the ability to install Python libraries, manipulate the web page's [DOM](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Introduction) from Python, and execute regular Python code entirely in the browser. A number of libraries have sprung up around Python in WASM, including [PyScript](https://pyscript.net/).
-
-Panel can be run directly in Pyodide and has special support for rendering in PyScript.
-
-This guide will take you through the process of either
-
-- Automatically converting Panel applications into a Pyodide/PyScript based application
-- Manually installing Panel in the browser and using it to render components.
-- Embedding Panel in your Sphinx documentation.
-- Setting up a Jupyterlite instance with support for Panel
-
-## Converting Panel applications
-
-Writing an HTML file from scratch with all the Javascript and Python dependencies and other boilerplate can be quite cumbersome, and requires learning a good bit of HTML. To avoid writing all the boilerplate, Panel provides support for converting an entire application (including Panel templates) to an HTML file, using the `panel convert` command-line interface (CLI). As a starting point create one or more Python scripts or notebook files containing your application. The only requirement is that they import only global modules and packages (relative imports of other scripts or modules is not supported) and that the libraries have been [compiled for Pyodide](https://github.com/pyodide/pyodide/tree/main/packages) or are available as pure-Python wheels from PyPI.
-
-The ``panel convert`` command has the following options:
-
-    positional arguments:
-      SCRIPTs               The scripts or notebooks to convert
-
-    optional arguments:
-      -h, --help            Show this help message and exit
-      --to                  The format to convert to, one of 'pyodide', 'pyodide-worker' or 'pyscript'
-      --out                 Directory to export files to
-      --title               Custom title for the application(s)
-      --skip-embed          Whether to skip the prerendering while pyodide loads.
-      --index               Whether to create an index if multiple files are served.
-      --pwa                 Whether to add files to allow serving the application as a Progressive Web App.
-      --requirements        List of Python requirements to add to the converted file. By default it will automatically try to infer dependencies based on your imports and Panel will automatically be included.
-      --watch               Watches files for changes and rebuilds them when they are updated.
-      --disable-http-patch  Disables patching of http requests using pyodide-http library.
-
-### Example
-
-This example will demonstrate how to *convert* and *serve* a basic data app locally.
-
-- Create a `script.py` file with the following content
-
-```python
-import panel as pn
-
-from sklearn.datasets import load_iris
-from sklearn.metrics import accuracy_score
-from xgboost import XGBClassifier
-
-pn.extension(sizing_mode="stretch_width", template="fast")
-pn.state.template.param.update(site="Panel in the Browser", title="XGBoost Example")
-
-iris_df = load_iris(as_frame=True)
-
-trees = pn.widgets.IntSlider(start=2, end=30, name="Number of trees")
-
-def pipeline(trees):
-    model = XGBClassifier(max_depth=2, n_estimators=trees)
-    model.fit(iris_df.data, iris_df.target)
-    accuracy = round(accuracy_score(iris_df.target, model.predict(iris_df.data)) * 100, 1)
-    return pn.indicators.Number(
-        name="Test score",
-        value=accuracy,
-        format="{value}%",
-        colors=[(97.5, "red"), (99.0, "orange"), (100, "green")],
-    )
-
-pn.Column(
-    "Simple example of training an XGBoost classification model on the small Iris dataset.",
-    iris_df.data.head(),
-    "Move the slider below to change the number of training rounds for the XGBoost classifier. The training accuracy score will adjust accordingly.",
-    trees,
-    pn.bind(pipeline, trees),
-).servable()
-```
-
-- Run `panel convert script.py --to pyodide-worker --out pyodide`
-- Run `python3 -m http.server` to start a web server locally
-- Open `http://localhost:8000/pyodide/script.html` to try out the app.
-
-The app should look like this
-
-![Panel in the browser](../_static/images/pyodide_xgboost_app.png)
-
-You can now add the `script.html` (and `script.js` file if you used the `pyodide-worker` target) to your Github pages or similar. **no separate server needed!**
-
-#### Tips & Tricks for development
-
-- While developing you should run the script locally with *auto reload*: `panel serve script.py --autoreload`.
-- You can also watch your script for changes and rebuild it if you make an edit with `panel convert ... --watch`
-- If the converted app does not work as expected, you can most often find the errors in the browser
-console. [This guide](https://balsamiq.com/support/faqs/browserconsole/) describes how to open the
-console.
-- You can find answers to the most frequently asked questions about *Python in the browser* in the [Pyodide - FAQ](https://pyodide.org/en/stable/usage/faq.html) or the [PyScript FAQ](https://docs.pyscript.net/latest/reference/faq.html). For example the answer to "How can I load external data?".
-
-### Formats
-
-Using the `--to` argument on the CLI you can control the format of the file that is generated by `panel convert`. You have three options, each with distinct advantages and disadvantages:
-
-- **`pyodide`** (default): Run application using Pyodide running in the main thread. This option is less performant than pyodide-worker but produces completely standalone HTML files that do not have to be hosted on a static file server (e.g. Github Pages).
-- **`pyodide-worker`**: Generates an HTML file and a JS file containing a Web Worker that runs in a separate thread. This is the most performant option, but files have to be hosted on a static file server.
-- **`pyscript`**: Generates an HTML leveraging PyScript. This produces standalone HTML files containing `<py-env>` and `<py-script>` tags containing the dependencies and the application code. This output is the most readable, and should have equivalent performance to the `pyodide` option.
-
-### Requirements
-
-The `panel convert` command will try its best to figure out the requirements of your script based on the imports, which means that in most cases you won't have to provide the explicit `--requirements` argument. However, if some library uses an optional import that cannot be inferred from the list of imports in your app you will have to provide an explicit list of dependencies. Note that `panel` and its dependencies including NumPy and Bokeh will be added loaded automatically, e.g. the explicit requirements for the app above would look like this:
-
-```bash
-panel convert script.py --to pyodide-worker --out pyodide --requirements xgboost scikit-learn pandas
-```
-
-Alternatively you may also provide a `requirements.txt` file:
-
-```bash
-panel convert script.py --to pyodide-worker --out pyodide --requirements requirements.txt
-```
-
-### Index
-
-If you convert multiple applications at once you may want to add an index to be able to navigate between the applications easily. To enable the index simply pass `--index` to the convert command.
-
-### Prerendering
-
-In order to improve the loading experience Panel will pre-render and embed the initial render of the page and replace it with live components once the page is loaded. This is important because Pyodide has to fetch the entire Python runtime and all required packages from a CDN. This can be **very** slow depending on your internet connection. If you want to disable this behavior and render an initially blank page use the `--skip-embed` option. Otherwise Panel will render application using the current Python process (presumably outside the browser) into the HTML file as a "cached" copy of the application for the user to see while the Python runtime is initialized and the actual browser-generated application is ready for interaction.
-
-### Progressive Web Apps
-
-Progressive web applications (PWAs) provide a way for your web apps to behave almost like a native application, both on mobile devices and on the desktop. The `panel convert` CLI has a `--pwa` option that will generate the necessary files to turn your Panel + Pyodide application into a PWA. The web manifest, service worker script and assets such as thumbnails are exported alongside the other HTML and JS files and can then be hosted on your static file host. Note that Progressive web apps must be served via HTTPS to ensure user privacy, security, and content authenticity, including the application itself and all resources it references. Depending on your hosting service, you will have to enable HTTPS yourself. GitHub pages generally make this very simple and provide a great starting point.
-
-Once generated, you can inspect the `site.webmanifest` file and modify it to your liking, including updating the favicons in the assets directory.
-
-```{note}
-If you decide to enable the `--pwa` ensure that you also provide a unique `--title`. Otherwise the browser caches storing your apps dependencies will end up overwriting each other.
-```
-
-### Handling HTTP requests
-
-By default Panel 0.14.1 will install the [pyodide-http](https://github.com/koenvo/pyodide-http) library which patches `urllib3` and `requests` making it possible to use them within the pyodide process. To disable this behavior use the `--disable-http-patch` CLI option.
-
-Note that making HTTP requests when converting to the `pyodide` or `pyscript` target will block the main browser thread and result in a poor user experience. Therefore we strongly recommend converting to `pyodide-worker` if your app is making synchronous HTTP requests.
-
-## Installing Panel in the browser
-
-To install Panel in the browser you merely have to use the installation mechanism provided by each supported runtime:
-
-### Pyodide
-
-Currently the best supported mechanism for installing packages in Pyodide is `micropip`.
-
-To get started with Pyodide simply follow their [Getting started guide](https://pyodide.org/en/stable/usage/quickstart.html). Note that if you want to render Panel output you will also have to load [Bokeh.js](https://docs.bokeh.org/en/2.4.1/docs/first_steps/installation.html#install-bokehjs:~:text=Installing%20standalone%20BokehJS%C2%B6) and Panel.js from CDN. The most basic pyodide application therefore looks like this:
-
-```html
-<!DOCTYPE html>
-<html>
-  <head>
-    <script src="https://cdn.jsdelivr.net/pyodide/v0.21.2/full/pyodide.js"></script>
-
-    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.js"></script>
-    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js"></script>
-    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js"></script>
-    <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/@holoviz/panel@0.14.0/dist/panel.min.js"></script>
-
-  </head>
-  <body>
-    <div id="simple_app"></div>
-    <script type="text/javascript">
-      async function main(){
-        let pyodide = await loadPyodide();
-        await pyodide.loadPackage("micropip");
-        const micropip = pyodide.pyimport("micropip");
-        await micropip.install('panel')
-        pyodide.runPython(`
-          import panel as pn
-
-          pn.extension(sizing_mode="stretch_width")
-
-          slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
-
-          def callback(new):
-              return f'Amplitude is: {new}'
-
-          pn.Row(slider, pn.bind(callback, slider)).servable(target='simple_app');
-	    `);
-      }
-      main();
-    </script>
-  </body>
-</html>
-```
-
-The app should look like this
-
-![Panel Pyodide App](../_static/images/pyodide_app_simple.png)
-
-:::{admonition}
-The default bokeh and panel packages are very large, therefore we recommend you pip install specialized wheels:
-
-```javascript
-const bk_whl = "https://cdn.holoviz.org/panel/0.14.0/wheels/bokeh-2.4.3-py3-none-any.whl"
-const pn_whl = "https://cdn.holoviz.org/panel/0.14.0/wheels/panel-0.14.0-py3-none-any.whl"
-await micropip.install(bk_whl, pn_whl)
-```
-:::
-
-### PyScript
-
-PyScript makes it even easier to manage your dependencies, with a `<py-config>` HTML tag. Simply include `panel` in the list of dependencies and PyScript will install it automatically:
-
-```html
-<py-config>
-packages = [
-  "panel",
-  ...
-]
-</py-config>
-```
-
-Once installed you will be able to `import panel` in your `<py-script>` tag. Again, make sure you also load Bokeh.js and Panel.js:
-
-```html
-<!DOCTYPE html>
-<html>
-  <head>
-    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.js"></script>
-    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js"></script>
-    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js"></script>
-    <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/@holoviz/panel@0.14.0/dist/panel.min.js"></script>
-
-    <link rel="stylesheet" href="https://pyscript.net/releases/2022.09.1/pyscript.css" />
-    <script defer src="https://pyscript.net/releases/2022.09.1/pyscript.js"></script>
-  </head>
-  <body>
-    <py-config>
-       packages = [
-         "panel",
-         ...
-       ]
-    </py-config>
-    <div id="simple_app"></div>
-    <py-script>
-      import panel as pn
-
-      pn.extension(sizing_mode="stretch_width")
-
-      slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
-
-      def callback(new):
-         return f'Amplitude is: {new}'
-
-      pn.Row(slider, pn.bind(callback, slider)).servable(target='simple_app');
-    </py-script>
-  </body>
-</html>
-```
-
-The app should look identical to the one above but show a loading spinner while Pyodide is initializing.
-
-### Rendering Panel components in Pyodide or Pyscript
-
-Rendering Panel components into the DOM is quite straightforward. You can simply use the `.servable()` method on any component and provide a target that should match the `id` of a DOM node:
-
-```python
-import panel as pn
-
-slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
-
-def callback(new):
-    return f'Amplitude is: {new}'
-
-pn.Row(slider, pn.bind(callback, slider)).servable(target='simple_app');
-```
-
-This code will render this simple application into the `simple_app` DOM node:
-
-```html
-<div id="simple_app"></div>
-```
-
-Alternatively you can also use the `panel.io.pyodide.write` function to write into a particular DOM node:
-
-```python
-await pn.io.pyodide.write('simple_app', component)
-```
-
-## Embedding in Sphinx documentation
-
-One more option is to include live Panel examples in your Sphinx documentation using the `nbsite.pyodide` directive.
-
-### Setup
-
-In the near future we hope to make this a separate Sphinx extension, until then simply install latest nbsite with `pip` or `conda`:
-
-::::{tab-set}
-:::{tab-item} Conda
-:sync: conda
-
-``` bash
-conda install -c pyviz nbsite
-```
-
-:::
-:::{tab-item} Pip
-:sync: pip
-
-``` bash
-pip install nbsite
-```
-:::
-::::
-
-add the extension to the Sphinx `conf.py`:
-
-```python
-extensions += [
-    ...,
-    'nbsite.pyodide'
-]
-```
-
-### Configuration
-
-In the `conf.py` of your project you can configure the extension in a number of ways by defining an `nbsite_pyodide_conf` dictionary with the following options:
-
-- `PYODIDE_URL`: The URl to fetch Pyodide from
-- `autodetect_deps` (default=`True`): Whether to automatically detect dependencies in the executed code and install them.
-- `enable_pwa` (default=`True`): Whether to add a web manifest and service worker to configure the documentation as a progressive web app.
-- `requirements` (default=`['panel']`): Default requirements to include (by default this includes just panel.
-- `scripts`: Scripts to add to the website when a Pyodide cell is first executed.
-- `setup_code` (default=`''`): Python code to run when initializing the Pyodide runtime.
-
-and then you can use the `pyodide` as an RST directive:
-
-```rst
-.. pyodide::
-
-   import panel as pn
-
-   slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
-
-   def callback(new):
-       return f'Amplitude is: {new}'
-
-   pn.Row(slider, pn.bind(callback, slider))
-```
-
-### Examples
-
-The resulting output looks like this:
-
-```{pyodide}
-import panel as pn
-```
-
-
-```{pyodide}
-slider = pn.widgets.FloatSlider(start=0, end=10, name='Amplitude')
-
-def callback(new):
-    return f'Amplitude is: {new}'
-
-pn.Row(slider, pn.bind(callback, slider))
-```
-
-In addition to rendering Panel components it also renders regular Pytho
-types:
-
-```{pyodide}
-1+1
-```
-
-
-```{pyodide}
-"A string"
-```
-
-and also handles stdout and stderr streams:
-
-```{pyodide}
-import numpy as np
-for i in range(10):
-    print(f'Repeat {i}')
-    for i in range(10000):
-        np.random.rand(1000)
-```
-
-```{pyodide}
-raise ValueError('Encountered an error')
-```
-
-and supports `_repr_<mime>_` methods that are commonly used by the IPython and Jupyter ecosystem:
-
-```{pyodide}
-class HTML:
-
-    def __init__(self, html):
-	    self.html = html
-
-    def _repr_html_(self):
-	    return self.html
-
-HTML('<b>HTML!</b>')
-```
-
-### Usage
-
-The code cell will display a button to execute the cell, which will warn about downloading the Python runtime on first-click and ask you to confirm whether you want to proceed. It will then download Pyodide, all required packages and finally display the output.
-
-## Setting up JupyterLite
-
-[JupyterLite](https://jupyterlite.readthedocs.io/en/latest/) is a JupyterLab distribution built from all the usual components and extensions that come with JupyterLab, but now running entirely in the browser with no external server needed. In order to use Panel in JupyterLite you will have to build your own distribution. As a starting point we recommend [this guide](https://jupyterlite.readthedocs.io/en/latest/howto/configure/simple_extensions.html) in the JupyterLite documentation, which will tell you how to set up an environment to begin building JupyterLite.
-
-### Create a `<lite-dir>`
-
-Once your environment is set up, create a new directory, which will become the source for your JupyterLite distribution. Once created place the file contents you want to make available in JupyterLite into `<lite-dir>/files`.
-
-### Adding extensions
-
-In order for Panel to set up communication channels inside JupyterLite we have to add the `pyviz_comms` extension to the environment. Ensure this package is installed in the environment you are building Panel from, e.g. by running `pip install pyviz_comms` OR by including it in the `requirements.txt` you used when setting up your build environment.
-
-### Optimized wheels (optional)
-
-To get Panel installed inside a Jupyterlite session we have to install it with `piplite`. The default Bokeh and Panel packages are quite large since they contain contents which are needed in a server environment. Since we will be running inside Jupyter these contents are not needed. To bundle the optimized packages download them from the CDN and place them in the `<lite-dir>/pypi` directory. You can download them from the CDN (replacing the latest version numbers):
-
-```
-https://cdn.holoviz.org/panel/0.14.2/dist/wheels/bokeh-2.4.3-py3-none-any.whl
-https://cdn.holoviz.org/panel/0.14.2/dist/wheels/panel-0.14.2-py3-none-any.whl
-```
-
-### Building Panel lite
-
-Finally `cd` into your `<lite-dir>` and run `jupyter lite build --output-dir ./dist`. This will bundle up the file contents, extensions and wheels into your JupyterLite distribution. You can now easily deploy this to [GitHub pages](https://jupyterlite.readthedocs.io/en/latest/quickstart/deploy.html) or elsewhere.
diff --git a/doc/user_guide/index.rst b/doc/user_guide/index.rst
index 4e602ba4b4..949a94745a 100644
--- a/doc/user_guide/index.rst
+++ b/doc/user_guide/index.rst
@@ -56,9 +56,6 @@ when needed.
 State, Caching & Callbacks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-`Session State and Callbacks <Session_State_and_Callbacks.html>`_
- Learn how to access session state and schedule callbacks.
-
 `Asynchronous and Concurrent Processing <Async_and_Concurrency.html>`_
  Learn how leverage asynchronous and concurrent processing to make your app more responsive.
 
@@ -68,34 +65,12 @@ Export
 `Display & Export <Display_and_Export.html>`_
  Guide towards configuring and displaying output and exporting Panel apps and components.
 
-`Running Panel in the Browser with WASM <Running_in_Webassembly.html>`_
- Guide to embedding interactive Panel components in a web page or converting entire Panel applications to run entirely in your browser.
-
-Server Usage
-^^^^^^^^^^^^
-
-`Server configuration <Server_Configuration.html>`_
- A guide detailing how to launch and configure a server from the commandline or programmatically.
-
-`Server Deployment <Server_Deployment.html>`_
- Step-by-step guides for deploying Panel apps locally, on a web server or on common cloud providers.
-
-`Authentication <Authentication.html>`_
- Learn how to add an authentication component in front of your application.
-
-`Django Integration <Django.html>`_
- How to embed a Panel/Bokeh app inside a Django web-server deployment.
-
-`FastAPI Integration <FastAPI.html>`_
- How to embed a Panel/Bokeh app inside a FastAPI web-server deployment.
-
 Extending Panel
 ^^^^^^^^^^^^^^^
 
 `Building custom components <Custom_Components.html>`_
  Learn how to extend Panel by building custom components.
 
-
 .. toctree::
     :titlesonly:
     :hidden:
@@ -112,13 +87,6 @@ Extending Panel
     Pipelines <Pipelines>
     Templates <Templates>
     Performance and Debugging <Performance_and_Debugging>
-    Session state & Callbacks <Session_State_and_Callbacks>
     Asynchronous and Concurrent Process <Async_and_Concurrency>
     Display & Export <Display_and_Export>
-    Running Panel in the Browser with WASM <Running_in_Webassembly>
-    Server Configuration <Server_Configuration>
-    Server Deployment <Server_Deployment>
-    Authentication <Authentication>
-    Django Integration <Django>
-    FastAPI Integration <FastAPI>
     Building Custom Components <Custom_Components>
diff --git a/examples/user_guide/Display_and_Export.ipynb b/examples/user_guide/Display_and_Export.ipynb
index c5f9837012..11526e819f 100644
--- a/examples/user_guide/Display_and_Export.ipynb
+++ b/examples/user_guide/Display_and_Export.ipynb
@@ -188,149 +188,6 @@
     "conda install -c bokeh jupyter_bokeh\n",
     "```"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Accessing the Bokeh model\n",
-    "\n",
-    "Since Panel is built on top of Bokeh, all Panel objects can easily be converted to a Bokeh model. The ``get_root`` method returns a model representing the contents of a Panel:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model = pn.Column('# Some markdown').get_root()\n",
-    "model"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "By default this model will be associated with Bokeh's ``curdoc()``, so if you want to associate the model with some other ``Document`` ensure you supply it explictly as the first argument. Once you have access to the underlying bokeh model you can use all the usual bokeh utilities such as ``components``, ``file_html``, or ``show``"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from bokeh.embed import components, file_html\n",
-    "from bokeh.io import show\n",
-    "\n",
-    "script, html = components(model)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Embedding\n",
-    "\n",
-    "Panel generally relies on either the Jupyter kernel or a Bokeh Server to be running in the background to provide interactive behavior. However for simple apps with a limited amount of state it is also possible to `embed` all the widget state, allowing the app to be used entirely from within Javascript. To demonstrate this we will create a simple app which simply takes a slider value, multiplies it by 5 and then display the result."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "slider = pn.widgets.IntSlider(start=0, end=10)\n",
-    "\n",
-    "@pn.depends(slider.param.value)\n",
-    "def callback(value):\n",
-    "    return '%d * 5 = %d' % (value, value*5)\n",
-    "\n",
-    "row = pn.Row(slider, callback)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If we displayed this the normal way it would call back into Python every time the value changed. However, the `.embed()` method will record the state of the app for the different widget configurations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "row.embed()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you try the widget above you will note that it only has 3 different states, 0, 5 and 10. This is because by default embed will try to limit the number of options of non-discrete or semi-discrete widgets to at most three values. This can be controlled using the `max_opts` argument to the embed method or you can provide an explicit list of `states` to embed for each widget:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "row.embed(states={slider: list(range(0, 12, 2))})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    " The full set of options for the embed method include:\n",
-    "\n",
-    "- **`max_states`**: The maximum number of states to embed\n",
-    "\n",
-    "- **`max_opts`**: The maximum number of states for a single widget\n",
-    "\n",
-    "- **`states`** (default={}): A dictionary specifying the widget values to embed for each widget\n",
-    "\n",
-    "- **`json`** (default=True): Whether to export the data to json files\n",
-    "\n",
-    "- **`save_path`** (default='./'): The path to save json files to\n",
-    "\n",
-    "- **`load_path`** (default=None):  The path or URL the json files will be loaded from (same as ``save_path`` if not specified)\n",
-    "\n",
-    "* **`progress`** (default=False): Whether to report progress\n",
-    "\n",
-    "\n",
-    "As you might imagine if there are multiple widgets there can quickly be a combinatorial explosion of states so by default the output is limited to about 1000 states. For larger apps the states can also be exported to json files, e.g. if you want to serve the app on a website specify the ``save_path`` to declare where it will be stored and the ``load_path`` to declare where the JS code running on the website will look for the files."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Saving \n",
-    "\n",
-    "In case you don't need an actual server or simply want to export a static snapshot of a panel app, you can use the ``save`` method, which allows exporting the app to a standalone HTML or PNG file.\n",
-    "\n",
-    "By default, the HTML file generated will depend on loading JavaScript code for BokehJS from the online ``CDN`` repository, to reduce the file size. If you need to work in an airgapped or no-network environment, you can declare that ``INLINE`` resources should be used instead of ``CDN``:\n",
-    "\n",
-    "```python\n",
-    "from bokeh.resources import INLINE\n",
-    "panel.save('test.html', resources=INLINE)\n",
-    "```\n",
-    "\n",
-    "Additionally the save method also allows enabling the `embed` option, which, as explained above, will embed the apps state in the app or save the state to json files which you can ship alongside the exported HTML.\n",
-    "\n",
-    "Finally, if a 'png' file extension is specified, the exported plot will be rendered as a PNG, which currently requires Selenium and PhantomJS to be installed:\n",
-    "\n",
-    "```python\n",
-    "pane.save('test.png')\n",
-    "\n",
-    "```"
-   ]
   }
  ],
  "metadata": {
diff --git a/examples/user_guide/Performance_and_Debugging.ipynb b/examples/user_guide/Performance_and_Debugging.ipynb
index 12b765c140..9acc6636d3 100644
--- a/examples/user_guide/Performance_and_Debugging.ipynb
+++ b/examples/user_guide/Performance_and_Debugging.ipynb
@@ -15,86 +15,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "When developing applications that are to be used by multiple users and which may process a lot of data it is important to ensure the application is well optimized. Additionally complex applications may have very complex callbacks which are difficult to trace and debug. In this user guide section we will walk you some of the best practices to debug your applications and profile your application to maximize performance.\n",
-    "\n",
-    "## Caching\n",
-    "\n",
-    "Caching data and computation is one of the most effective ways to speed up your applications. Some common examples of scenarios that benefit from caching is working with large datasets that you have to load from disk or over a network connection or you have to perform expensive computations that don't depend on any extraneous state. Panel makes it easy for you to add caching to you applications using a few approaches. Panel' architecture is also very well suited towards caching since multiple user sessions can run in the same process and therefore have access to the same global state. This means that we can cache data in Panel's global `state` object, either by directly assigning to the `pn.state.cache` dictionary object, using the `pn.state.as_cached` helper function or the `pn.cache` decorator. Once cached all current and subsequent sessions will be sped up by having access to the cache.\n",
-    "\n",
-    "### Manual usage\n",
-    "\n",
-    "To assign to the cache manually, simply put the data load or expensive calculation in an `if`/`else` block which checks whether the custom key is already present: \n",
-    "\n",
-    "```python\n",
-    "if 'data' in pn.state.cache:\n",
-    "    data = pn.state.cache['data']\n",
-    "else:\n",
-    "    pn.state.cache['data'] = data = ... # Load some data or perform an expensive computation\n",
-    "```\n",
-    "\n",
-    "### `pn.cache` decorator\n",
-    "\n",
-    "The `pn.cache` decorator provides an easy way to cache the outputs of a function depending on its inputs (i.e. `memoize`). If you've ever used the Python `@lru_cache` decorator you will be familiar with this concept. However the `pn.cache` functions supports additional cache `policy`'s apart from LRU (least-recently used), including `LFU` (least-frequently-used) and 'FIFO' (first-in-first-out). This means that if the specified number of `max_items` is reached Panel will automatically evict items from the cache based on this `policy`. Additionally items can be deleted from the cache based on a `ttl` (time-to-live) value given in seconds.\n",
-    "\n",
-    "#### Caching in memory\n",
-    "\n",
-    "The `pn.cache` decorator can easily be combined with the different Panel APIs including `pn.bind` and `pn.depends` providing a powerful way to speed up your applications.\n",
-    "\n",
-    "```python\n",
-    "@pn.cache(max_items=10, policy='LRU')\n",
-    "def load_data(path):\n",
-    "    return ... # Load some data\n",
-    "```\n",
-    "\n",
-    "Once you have decorated your function with `pn.cache` any call to `load_data` will be cached in memory until `max_items` value is reached (i.e. you have loaded 10 different `path` values). At that point the `policy` will determine which item is evicted.\n",
-    "\n",
-    "The `pn.cache` decorator can easily be combined with `pn.bind` to speed up rendering of your reactive components:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "select = pn.widgets.Select(options={\n",
-    "    'Penguins': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv',\n",
-    "    'Diamonds': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv',\n",
-    "    'Titanic': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv',\n",
-    "    'MPG': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv'\n",
-    "})\n",
-    "\n",
-    "@pn.cache\n",
-    "def fetch_data(url):\n",
-    "    return pd.read_csv(url)\n",
-    "\n",
-    "pn.Column(select, pn.bind(pn.widgets.Tabulator, pn.bind(fetch_data, select), page_size=10))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Disk caching\n",
-    "\n",
-    "If you have `diskcache` installed you can also cache the results to disk by setting `to_disk=True`. The `diskcache` library will then cache the value to the supplied `cache_path` (defaulting to `./cache`). Making use of disk caching allows you to cache items even if the server is restarted.\n",
-    "\n",
-    "#### Clearing the cache\n",
-    "\n",
-    "Once a function has been decorated with `pn.cache` you can easily clear the cache by calling `.clear()` on that function, e.g. in the example above you could call `load_data.clear()`. If you want to clear all caches you may also call `pn.state.clear_caches()`.\n",
-    "\n",
-    "### `pn.state.as_cached`\n",
-    "\n",
-    "The `as_cached` helper function on the other hand allows providing a custom key and a function and automatically caching the return value. If provided the `args` and `kwargs` will also be hashed making it easy to cache (or memoize) on the arguments to the function: \n",
-    "\n",
-    "```python\n",
-    "def load_data(*args, **kwargs):\n",
-    "    return ... # Load some data\n",
-    "\n",
-    "data = pn.state.as_cached('data', load_data, *args, **kwargs)\n",
-    "```\n",
-    "\n",
-    "The first time the app is loaded the data will be cached and subsequent sessions will simply look up the data in the cache, speeding up the process of rendering. If you want to warm up the cache before the first user visits the application you can also provide the `--warm` argument to the `panel serve` command, which will ensure the application is initialized as soon as it is launched. If you want to populate the cache in a separate script from your main application you may also provide the path to a setup script using the `--setup` argument to `panel serve`. If you want to periodically update the cache look into the ability to [schedule tasks](Deploy_and_Export.ipynb#Scheduling-task-with-pn.state.schedule_task).\n"
+    "When developing applications that are to be used by multiple users and which may process a lot of data it is important to ensure the application is well optimized. Additionally complex applications may have very complex callbacks which are difficult to trace and debug. In this user guide section we will walk you some of the best practices to debug your applications and profile your application to maximize performance."
    ]
   },
   {
@@ -226,66 +147,7 @@
     "... 2 second wait\n",
     "> Finished processing 1th click.\n",
     "> Finished processing 2th click.\n",
-    "```\n",
-    "\n",
-    "### AsyncIO\n",
-    "\n",
-    "When using Python>=3.8 you can use async callbacks wherever you would ordinarily use a regular synchronous function. For instance you can use `pn.bind` on an async function:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import aiohttp\n",
-    "\n",
-    "widget = pn.widgets.IntSlider(start=0, end=10)\n",
-    "\n",
-    "async def get_img(index):\n",
-    "    async with aiohttp.ClientSession() as session:\n",
-    "        async with session.get(f\"https://picsum.photos/800/300?image={index}\") as resp:\n",
-    "            return pn.pane.JPG(await resp.read())\n",
-    "            \n",
-    "pn.Column(widget, pn.bind(get_img, widget))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this example Panel will invoke the function and update the output when the function returns while leaving the process unblocked for the duration of the `aiohttp` request. \n",
-    "\n",
-    "Similarly you can attach asynchronous callbacks using `.param.watch`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "widget = pn.widgets.IntSlider(start=0, end=10)\n",
-    "\n",
-    "image = pn.pane.JPG()\n",
-    "\n",
-    "async def update_img(event):\n",
-    "    async with aiohttp.ClientSession() as session:\n",
-    "        async with session.get(f\"https://picsum.photos/800/300?image={event.new}\") as resp:\n",
-    "            image.object = await resp.read()\n",
-    "            \n",
-    "widget.param.watch(update_img, 'value')\n",
-    "widget.param.trigger('value')\n",
-    "            \n",
-    "pn.Column(widget, image)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this example Param will await the asynchronous function and the image will be updated when the request completes."
+    "```"
    ]
   },
   {
diff --git a/examples/user_guide/Session_State_and_Callbacks.ipynb b/examples/user_guide/Session_State_and_Callbacks.ipynb
deleted file mode 100644
index 64f003388c..0000000000
--- a/examples/user_guide/Session_State_and_Callbacks.ipynb
+++ /dev/null
@@ -1,361 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import panel as pn\n",
-    "\n",
-    "pn.extension()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Accessing session state\n",
-    "\n",
-    "Whenever a Panel app is being served the ``panel.state`` object exposes some of the internal Bokeh server components to a user.\n",
-    "\n",
-    "#### Document\n",
-    "\n",
-    "The current Bokeh ``Document`` can be accessed using ``panel.state.curdoc``.\n",
-    "\n",
-    "#### Request arguments\n",
-    "\n",
-    "When a browser makes a request to a Bokeh server a session is created for the Panel application. The request arguments are made available to be accessed on ``pn.state.session_args``. For example if your application is hosted at ``localhost:8001/app``, appending ``?phase=0.5`` to the URL will allow you to access the phase variable using the following code:\n",
-    "\n",
-    "```python\n",
-    "try:\n",
-    "    phase = int(pn.state.session_args.get('phase')[0])\n",
-    "except Exception:\n",
-    "    phase = 1\n",
-    "```\n",
-    "\n",
-    "This mechanism may be used to modify the behavior of an app dependending on parameters provided in the URL. \n",
-    "\n",
-    "#### Cookies\n",
-    "\n",
-    "The `panel.state.cookies` will allow accessing the cookies stored in the browser and on the bokeh server.\n",
-    "\n",
-    "#### Headers\n",
-    "\n",
-    "The `panel.state.headers` will allow accessing the HTTP headers stored in the browser and on the bokeh server.\n",
-    "\n",
-    "#### Location\n",
-    "\n",
-    "When starting a server session Panel will attach a `Location` component which can be accessed using `pn.state.location`. The `Location` component servers a number of functions:\n",
-    "\n",
-    "- Navigation between pages via ``pathname``\n",
-    "- Sharing (parts of) the page state in the url as ``search`` parameters for bookmarking and sharing.\n",
-    "- Navigating to subsections of the page via the ``hash_`` parameter.\n",
-    "\n",
-    "##### Core\n",
-    "\n",
-    "* **``pathname``** (string): pathname part of the url, e.g. '/user_guide/Interact.html'.\n",
-    "* **``search``** (string): search part of the url e.g. '?color=blue'.\n",
-    "* **``hash_``** (string): hash part of the url e.g. '#interact'.\n",
-    "* **``reload``** (bool): Whether or not to reload the page when the url is updated.\n",
-    "    - For independent apps this should be set to True. \n",
-    "    - For integrated or single page apps this should be set to False.\n",
-    "\n",
-    "##### Readonly\n",
-    "\n",
-    "* **``href``** (string): The full url, e.g. 'https://panel.holoviz.org/user_guide/Interact.html:80?color=blue#interact'.\n",
-    "* **``protocol``** (string): protocol part of the url, e.g. 'http:' or 'https:'\n",
-    "* **``port``** (string): port number, e.g. '80'\n",
-    "\n",
-    "#### pn.state.busy\n",
-    "\n",
-    "Often an application will have longer running callbacks which are being processed on the server, to give users some indication that the server is busy you may therefore have some way of indicating that busy state. The `pn.state.busy` parameter indicates whether a callback is being actively processed and may be linked to some visual indicator.\n",
-    "\n",
-    "Below we will create a little application to demonstrate this, we will create a button which executes some longer running task on click and then create an indicator function that displays `'I'm busy'` when the `pn.state.busy` parameter is `True` and `'I'm idle'` when it is not:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import time\n",
-    "\n",
-    "def processing(event):\n",
-    "    # Some longer running task\n",
-    "    time.sleep(1)\n",
-    "    \n",
-    "button = pn.widgets.Button(name='Click me!')\n",
-    "button.on_click(processing)\n",
-    "\n",
-    "@pn.depends(pn.state.param.busy)\n",
-    "def indicator(busy):\n",
-    "    return \"I'm busy\" if busy else \"I'm idle\"\n",
-    "\n",
-    "pn.Row(button, indicator)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This way we can create a global indicator for the busy state instead of modifying all our callbacks."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Scheduling task with `pn.state.schedule_task`\n",
-    "\n",
-    "The `pn.state.schedule_task` functionality allows scheduling global tasks at certain times or on a specific schedule. This is distinct from periodic callbacks, which are scheduled per user session. Global tasks are useful for performing periodic actions like updating cached data, performing cleanup actions or other housekeeping tasks, while periodic callbacks should be reserved for making periodic updates to an application.\n",
-    "\n",
-    "The different contexts in which global tasks and periodic callbacks run also has implications on how they should be scheduled. Scheduled task **must not** be declared in the application code itself, i.e. if you are serving `panel serve app.py` the callback you are scheduling must not be declared in the `app.py`. It must be defined in an external module or in a separate script declared as part of the `panel serve` invocation using the `--setup` commandline argument.\n",
-    "\n",
-    "Scheduling using `pn.state.schedule_task` is idempotent, i.e. if a callback has already been scheduled under the same name subsequent calls will have no effect. By default the starting time is immediate but may be overridden with the `at` keyword argument. The period may be declared using the `period` argument or a cron expression (which requires the `croniter` library). Note that the `at` time should be in local time but if a callable is provided it must return a UTC time. If `croniter` is installed a `cron` expression can be provided using the `cron` argument.\n",
-    "\n",
-    "As a simple example of a task scheduled at a fixed interval:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import datetime as dt\n",
-    "import asyncio\n",
-    "\n",
-    "async def task():\n",
-    "    print(f'Task executed at: {dt.datetime.now()}')\n",
-    "\n",
-    "pn.state.schedule_task('task', task, period='1s')\n",
-    "await asyncio.sleep(3)\n",
-    "\n",
-    "pn.state.cancel_task('task')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that while both `async` and regular callbacks are supported, asynchronous callbacks are preferred if you are performing any I/O operations to avoid interfering with any running applications.\n",
-    "\n",
-    "If you have the `croniter` library installed you may also provide a cron expression, e.g. the following will schedule a task to be repeated at 4:02 am every Monday and Friday:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pn.state.schedule_task('task', task, cron='2 4 * * mon,fri')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "See [crontab.guru](https://crontab.guru/) and the [`croniter` README](https://github.com/kiorky/croniter#introduction) to learn about cron expressions genrally and special syntax supported by `croniter`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### pn.state.onload\n",
-    "\n",
-    "Another useful callback to define the onload callback, in a server context this will execute when a session is first initialized. Let us for example define a minimal example inside a function which we will pass to `pn.serve`. This emulates what happens when we call `panel serve` on the commandline. We will create a widget without populating its options, then we will add an `onload` callback, which will set the options once the initial page is loaded. Imagine for example that we have to fetch the options from some database which might take a little while, by deferring the loading of the options to the callback we can get something on the screen as quickly as possible and only run the expensive callback when we have already rendered something for the user to look at."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import time\n",
-    "\n",
-    "def app():\n",
-    "    widget = pn.widgets.Select()\n",
-    "\n",
-    "    def on_load():\n",
-    "        time.sleep(1) # Emulate some long running process\n",
-    "        widget.options = ['A', 'B', 'C']\n",
-    "\n",
-    "    pn.state.onload(on_load)\n",
-    "\n",
-    "    return widget\n",
-    "\n",
-    "# pn.serve(app) "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Alternatively we may also use the `defer_load` option to wait to evaluate a function until the page is loaded. This will render a placeholder and display the global `config.loading_spinner`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def render_on_load():\n",
-    "    return pn.widgets.Select(options=['A', 'B', 'C'])\n",
-    "\n",
-    "pn.Row(pn.panel(render_on_load, defer_load=True))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### pn.state.on_session_destroyed\n",
-    "\n",
-    "In many cases it is useful to define on_session_destroyed callbacks to perform any custom cleanup that is required, e.g,  dispose  a database engine, or when a user is logged out. These callbacks can be registered with `pn.state.on_session_destroyed(callback)`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Scheduling callbacks\n",
-    "\n",
-    "When you build an app you frequently want to schedule a callback to be run periodically to refresh the data and update visual components. Additionally if you want to update Bokeh components directly you may need to schedule a callback to get around Bokeh's document lock to avoid errors like this:\n",
-    "\n",
-    "> RuntimeError: _pending_writes should be non-None when we have a document lock, and we should have the lock when the document changes\n",
-    "\n",
-    "In this section we will discover how we can leverage Bokeh's Document and `pn.state.add_periodic_callback` to set this up.\n",
-    "\n",
-    "### Server callbacks\n",
-    "\n",
-    "The Bokeh server that Panel builds on is designed to be thread safe which requires a set of locks to avoid multiple threads modifying the Bokeh models simultaneously. Therefore if we want to work with Bokeh models directly we should ensure that any changes to a Bokeh model are executed on the correct thread by adding a callback, which the event loop will then execute safely.\n",
-    "\n",
-    "In the example below we will launch an application on a thread using `pn.serve` and make the Bokeh plot (in practice you may provide handles to this object on a class). To schedule schedule a callback which updates the `y_range` by using the `pn.state.execute` method. This pattern will ensure that the update to the Bokeh model is executed on the correct thread:\n",
-    "\n",
-    "```python\n",
-    "import time\n",
-    "import panel as pn\n",
-    "\n",
-    "from bokeh.plotting import figure\n",
-    "\n",
-    "def app():\n",
-    "    p = figure()\n",
-    "    p.line([1, 2, 3], [1, 2, 3])\n",
-    "    return p\n",
-    "\n",
-    "pn.serve(app, threaded=True)\n",
-    "\n",
-    "pn.state.execute(lambda: p.y_range.update(start=0, end=4))\n",
-    "```\n",
-    "\n",
-    "### Periodic callbacks\n",
-    "\n",
-    "As we discussed above periodic callbacks allow periodically updating your application with new data. Below we will create a simple Bokeh plot and display it with Panel:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from bokeh.models import ColumnDataSource\n",
-    "from bokeh.plotting import figure\n",
-    "\n",
-    "source = ColumnDataSource({\"x\": range(10), \"y\": range(10)})\n",
-    "p = figure()\n",
-    "p.line(x=\"x\", y=\"y\", source=source)\n",
-    "\n",
-    "bokeh_pane = pn.pane.Bokeh(p)\n",
-    "bokeh_pane.servable()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now we will define a callback that updates the data on the `ColumnDataSource` and use the `pn.state.add_periodic_callback` method to schedule updates every 200 ms. We will also set a timeout of 5 seconds after which the callback will automatically stop."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def update():\n",
-    "    data = np.random.randint(0, 2 ** 31, 10)\n",
-    "    source.data.update({\"y\": data})\n",
-    "    bokeh_pane.param.trigger('object') # Only needed in notebook\n",
-    "\n",
-    "cb = pn.state.add_periodic_callback(update, 200)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In a notebook or bokeh server context we should now see the plot update periodically. The other nice thing about this is that `pn.state.add_periodic_callback` returns `PeriodicCallback` we can call `.stop()` and `.start()` on if we want to stop or pause the periodic execution. Additionally we can also dynamically adjust the period by setting the `timeout` parameter to speed up or slow down the callback.\n",
-    "\n",
-    "Other nice features on a periodic callback are the ability to check the number of executions using the `cb.counter` property and the ability to toggle the callback on and off simply by setting the running parameter. This makes it possible to link a widget to the running state:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "toggle = pn.widgets.Toggle(name='Toggle callback', value=True)\n",
-    "\n",
-    "toggle.link(cb, bidirectional=True, value='running')\n",
-    "toggle"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that when starting a server dynamically with `pn.serve` you cannot start a periodic callback before the application is actually being served. Therefore you should create the application and start the callback in a wrapping function:\n",
-    "\n",
-    "```python\n",
-    "from functools import partial\n",
-    "\n",
-    "import numpy as np\n",
-    "import panel as pn\n",
-    "\n",
-    "from bokeh.models import ColumnDataSource\n",
-    "from bokeh.plotting import figure\n",
-    "\n",
-    "def update(source):\n",
-    "    data = np.random.randint(0, 2 ** 31, 10)\n",
-    "    source.data.update({\"y\": data})\n",
-    "\n",
-    "def panel_app():\n",
-    "    source = ColumnDataSource({\"x\": range(10), \"y\": range(10)})\n",
-    "    p = figure()\n",
-    "    p.line(x=\"x\", y=\"y\", source=source)\n",
-    "    cb = pn.state.add_periodic_callback(partial(update, source), 200, timeout=5000)\n",
-    "    return pn.pane.Bokeh(p)\n",
-    "\n",
-    "pn.serve(panel_app)\n",
-    "```"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python",
-   "pygments_lexer": "ipython3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

From 643a9a1a0601f20b474464c3f8aba3c0a522f877 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 3 Jan 2023 18:31:53 +0000
Subject: [PATCH 04/15] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 doc/how_to/authentication/configuration.md |  2 +-
 doc/how_to/authentication/index.md         |  2 +-
 doc/how_to/caching/index.md                |  2 +-
 doc/how_to/caching/manual.md               |  4 ++--
 doc/how_to/callbacks/async.md              | 10 +++++-----
 doc/how_to/callbacks/index.md              |  2 +-
 doc/how_to/callbacks/periodic.md           |  2 +-
 doc/how_to/callbacks/schedule.md           |  2 +-
 doc/how_to/callbacks/server.md             |  2 +-
 doc/how_to/callbacks/session.md            |  4 ++--
 doc/how_to/export/bokeh.md                 |  2 +-
 doc/how_to/export/embedding.md             |  2 +-
 doc/how_to/export/index.md                 |  2 +-
 doc/how_to/export/saving.md                |  2 +-
 doc/how_to/index.md                        |  2 +-
 doc/how_to/integrations/index.md           |  2 +-
 doc/how_to/server/index.md                 |  4 ++--
 doc/how_to/state/busy.md                   |  4 ++--
 doc/how_to/state/index.md                  |  4 ++--
 doc/how_to/state/request.md                |  2 +-
 doc/how_to/state/url.md                    |  6 +++---
 doc/how_to/wasm/index.md                   |  4 ++--
 22 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/doc/how_to/authentication/configuration.md b/doc/how_to/authentication/configuration.md
index 4a69fa8463..2b003de47e 100644
--- a/doc/how_to/authentication/configuration.md
+++ b/doc/how_to/authentication/configuration.md
@@ -114,4 +114,4 @@ A fully configured OAuth configuration may look like this:
 panel serve oauth_example.py --oauth-provider=github --oauth-key=... --oauth-secret=... --cookie-secret=... --oauth-encryption-key=...
 
 PANEL_OAUTH_PROVIDER=... PANEL_OAUTH_KEY=... PANEL_OAUTH_SECRET=... PANEL_COOKIE_SECRET=... PANEL_OAUTH_ENCRYPTION=... panel serve oauth_example.py ...`
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/authentication/index.md b/doc/how_to/authentication/index.md
index 66d088f1e3..266585ac1b 100644
--- a/doc/how_to/authentication/index.md
+++ b/doc/how_to/authentication/index.md
@@ -33,7 +33,7 @@ A list of OAuth providers and how to configure them.
 :link: user_info
 :link-type: doc
 
-Discover how to make use of the user information and access tokens returned by the OAuth provider. 
+Discover how to make use of the user information and access tokens returned by the OAuth provider.
 :::
 
 ::::
diff --git a/doc/how_to/caching/index.md b/doc/how_to/caching/index.md
index 9b48e4664e..0381eae407 100644
--- a/doc/how_to/caching/index.md
+++ b/doc/how_to/caching/index.md
@@ -28,4 +28,4 @@ How to use the `panel.cache` decorator to memoize (i.e. cache the output of) fun
 
 manual
 memoization
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/caching/manual.md b/doc/how_to/caching/manual.md
index 2205e9fc54..229e1a96b3 100644
--- a/doc/how_to/caching/manual.md
+++ b/doc/how_to/caching/manual.md
@@ -2,7 +2,7 @@
 
 The `panel.state.cache` object is a simple dictionary that is shared between all sessions on a particular Panel server process. This makes it possible to load large datasets (or other objects you want to share) once and subsequently access the cached object.
 
-To assign to the cache manually, simply put the data load or expensive calculation in an `if`/`else` block which checks whether the custom key is already present: 
+To assign to the cache manually, simply put the data load or expensive calculation in an `if`/`else` block which checks whether the custom key is already present:
 
 ```python
 if 'data' in pn.state.cache:
@@ -11,7 +11,7 @@ else:
     pn.state.cache['data'] = data = ... # Load some data or perform an expensive computation
 ```
 
-The `as_cached` helper function provides a slightly cleaner way to write the caching logic. Instead of writing a conditional statement you write a function that is executed only when the inputs to the function change. If provided the `args` and `kwargs` will also be hashed making it easy to cache (or memoize) on the arguments to the function: 
+The `as_cached` helper function provides a slightly cleaner way to write the caching logic. Instead of writing a conditional statement you write a function that is executed only when the inputs to the function change. If provided the `args` and `kwargs` will also be hashed making it easy to cache (or memoize) on the arguments to the function:
 
 ```python
 def load_data(*args, **kwargs):
diff --git a/doc/how_to/callbacks/async.md b/doc/how_to/callbacks/async.md
index 67bd3032aa..fded26f089 100644
--- a/doc/how_to/callbacks/async.md
+++ b/doc/how_to/callbacks/async.md
@@ -47,7 +47,7 @@ async def stream(event):
     x, y = cds.data['x'][-1], cds.data['y'][-1]
     cds.stream({'x': list(range(x+1, x+6)), 'y': y+np.random.randn(5).cumsum()})
     pane.param.trigger('object')
-    
+
 # Equivalent to `.on_click` but shown
 button.param.watch(stream, 'clicks')
 
@@ -65,11 +65,11 @@ async def get_img(index):
     async with aiohttp.ClientSession() as session:
         async with session.get(f"https://picsum.photos/800/300?image={index}") as resp:
             return pn.pane.JPG(await resp.read())
-            
+
 pn.Column(widget, pn.bind(get_img, widget))
 ```
 
-In this example Panel will invoke the function and update the output when the function returns while leaving the process unblocked for the duration of the `aiohttp` request. 
+In this example Panel will invoke the function and update the output when the function returns while leaving the process unblocked for the duration of the `aiohttp` request.
 
 The equivalent can be written using `.param.watch` as:
 
@@ -82,10 +82,10 @@ async def update_img(event):
     async with aiohttp.ClientSession() as session:
         async with session.get(f"https://picsum.photos/800/300?image={event.new}") as resp:
             image.object = await resp.read()
-            
+
 widget.param.watch(update_img, 'value')
 widget.param.trigger('value')
-            
+
 pn.Column(widget, image)
 ```
 
diff --git a/doc/how_to/callbacks/index.md b/doc/how_to/callbacks/index.md
index a627cf2829..dc40340d3e 100644
--- a/doc/how_to/callbacks/index.md
+++ b/doc/how_to/callbacks/index.md
@@ -58,4 +58,4 @@ session
 periodic
 schedule
 server
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/callbacks/periodic.md b/doc/how_to/callbacks/periodic.md
index ccfea09aa4..81647edf82 100644
--- a/doc/how_to/callbacks/periodic.md
+++ b/doc/how_to/callbacks/periodic.md
@@ -61,4 +61,4 @@ def panel_app():
     return pn.pane.Bokeh(p)
 
 pn.serve(panel_app)
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/callbacks/schedule.md b/doc/how_to/callbacks/schedule.md
index 5e48ae3aa6..9a5592bb3c 100644
--- a/doc/how_to/callbacks/schedule.md
+++ b/doc/how_to/callbacks/schedule.md
@@ -29,4 +29,4 @@ If you have the `croniter` library installed you may also provide a cron express
 pn.state.schedule_task('task', task, cron='2 4 * * mon,fri')
 ```
 
-See [crontab.guru](https://crontab.guru/) and the [`croniter` README](https://github.com/kiorky/croniter#introduction) to learn about cron expressions genrally and special syntax supported by `croniter`.
\ No newline at end of file
+See [crontab.guru](https://crontab.guru/) and the [`croniter` README](https://github.com/kiorky/croniter#introduction) to learn about cron expressions genrally and special syntax supported by `croniter`.
diff --git a/doc/how_to/callbacks/server.md b/doc/how_to/callbacks/server.md
index 59af138cd2..0eb14464f8 100644
--- a/doc/how_to/callbacks/server.md
+++ b/doc/how_to/callbacks/server.md
@@ -22,4 +22,4 @@ def app():
 pn.serve(app, threaded=True)
 
 pn.state.execute(lambda: p.y_range.update(start=0, end=4))
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/callbacks/session.md b/doc/how_to/callbacks/session.md
index 2531bef7cb..032ae733e9 100644
--- a/doc/how_to/callbacks/session.md
+++ b/doc/how_to/callbacks/session.md
@@ -1,6 +1,6 @@
 # Session callbacks
 
-Whenever a request is made to an endpoint that is serving a Panel application a new session is created. If you have to perform some setup or tear down tasks on session creation (e.g. logging) you can define `on_session_created` and `on_session_destroyed` callbacks. 
+Whenever a request is made to an endpoint that is serving a Panel application a new session is created. If you have to perform some setup or tear down tasks on session creation (e.g. logging) you can define `on_session_created` and `on_session_destroyed` callbacks.
 
 ## pn.state.on_session_created
 
@@ -8,4 +8,4 @@ WIP
 
 ## pn.state.on_session_destroyed
 
-In many cases it is useful to define on_session_destroyed callbacks to perform any custom cleanup that is required, e.g,  dispose  a database engine, or when a user is logged out. These callbacks can be registered with `pn.state.on_session_destroyed(callback)`
\ No newline at end of file
+In many cases it is useful to define on_session_destroyed callbacks to perform any custom cleanup that is required, e.g,  dispose  a database engine, or when a user is logged out. These callbacks can be registered with `pn.state.on_session_destroyed(callback)`
diff --git a/doc/how_to/export/bokeh.md b/doc/how_to/export/bokeh.md
index 09d26b05c4..8edefaea7e 100644
--- a/doc/how_to/export/bokeh.md
+++ b/doc/how_to/export/bokeh.md
@@ -14,4 +14,4 @@ from bokeh.embed import components, file_html
 from bokeh.io import show
 
 script, html = components(model)
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/export/embedding.md b/doc/how_to/export/embedding.md
index 276abb5af9..56ea012c55 100644
--- a/doc/how_to/export/embedding.md
+++ b/doc/how_to/export/embedding.md
@@ -40,4 +40,4 @@ row.embed(states={slider: list(range(0, 12, 2))})
 
 * **`progress`** (default=False): Whether to report progress
 
-As you might imagine if there are multiple widgets there can quickly be a combinatorial explosion of states so by default the output is limited to about 1000 states. For larger apps the states can also be exported to json files, e.g. if you want to serve the app on a website specify the ``save_path`` to declare where it will be stored and the ``load_path`` to declare where the JS code running on the website will look for the files.
\ No newline at end of file
+As you might imagine if there are multiple widgets there can quickly be a combinatorial explosion of states so by default the output is limited to about 1000 states. For larger apps the states can also be exported to json files, e.g. if you want to serve the app on a website specify the ``save_path`` to declare where it will be stored and the ``load_path`` to declare where the JS code running on the website will look for the files.
diff --git a/doc/how_to/export/index.md b/doc/how_to/export/index.md
index 885c325670..2b115086f3 100644
--- a/doc/how_to/export/index.md
+++ b/doc/how_to/export/index.md
@@ -10,4 +10,4 @@ One of the main design goals for Panel was that it should make it possible to se
 embedding
 saving
 bokeh
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/export/saving.md b/doc/how_to/export/saving.md
index 27d60966a8..42a65cbe0f 100644
--- a/doc/how_to/export/saving.md
+++ b/doc/how_to/export/saving.md
@@ -1,4 +1,4 @@
-# Saving output 
+# Saving output
 
 In case you don't need an actual server or simply want to export a static snapshot of a panel app, you can use the ``save`` method, which allows exporting the app to a standalone HTML or PNG file.
 
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index c91f5dba3b..b0d194dcfb 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -91,4 +91,4 @@ server/index
 integrations/index
 deployment/index
 authentication/index
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/integrations/index.md b/doc/how_to/integrations/index.md
index 66f6ab21d0..a0f435047c 100644
--- a/doc/how_to/integrations/index.md
+++ b/doc/how_to/integrations/index.md
@@ -16,7 +16,7 @@ Discover to run Panel applications alongside an existing Flask server.
 :link: FastAPI
 :link-type: doc
 
-Discover to run Panel applications alongside an existing FastAPI server. 
+Discover to run Panel applications alongside an existing FastAPI server.
 :::
 
 :::{grid-item-card} Django
diff --git a/doc/how_to/server/index.md b/doc/how_to/server/index.md
index 7f9e42298f..dba34970c8 100644
--- a/doc/how_to/server/index.md
+++ b/doc/how_to/server/index.md
@@ -33,7 +33,7 @@ Launch and configure a Panel application programmatically.
 :link: multiple
 :link-type: doc
 
-Discover how-to launch and configure multiple applications on the same server. 
+Discover how-to launch and configure multiple applications on the same server.
 :::
 
 :::{grid-item-card} {octicon}`server;2.5em;sd-mr-1` Setting up a (reverse) proxy
@@ -54,7 +54,7 @@ Discover how to access a Panel deployment running remotely via SSH.
 :link: static_files
 :link-type: doc
 
-Discover how to serve static files alongside your Panel application(s). 
+Discover how to serve static files alongside your Panel application(s).
 :::
 
 ::::
diff --git a/doc/how_to/state/busy.md b/doc/how_to/state/busy.md
index 0400a71ab6..bd9e472b6e 100644
--- a/doc/how_to/state/busy.md
+++ b/doc/how_to/state/busy.md
@@ -10,7 +10,7 @@ import time
 def processing(event):
     # Some longer running task
     time.sleep(1)
-    
+
 button = pn.widgets.Button(name='Click me!')
 button.on_click(processing)
 
@@ -20,4 +20,4 @@ def indicator(busy):
 pn.Row(button, pn.bind(indicator, pn.state.param.busy))
 ```
 
-This way we can create a global indicator for the busy state instead of modifying all our callbacks.
\ No newline at end of file
+This way we can create a global indicator for the busy state instead of modifying all our callbacks.
diff --git a/doc/how_to/state/index.md b/doc/how_to/state/index.md
index 9db6b92e90..ec0befcbb7 100644
--- a/doc/how_to/state/index.md
+++ b/doc/how_to/state/index.md
@@ -1,6 +1,6 @@
 # Accessing session state
 
-Whenever a Panel application is being served the `panel.state` object will provide a variety of information about the current user session including the HTTP request that initiated the session, information about the browser and the current URL and more. 
+Whenever a Panel application is being served the `panel.state` object will provide a variety of information about the current user session including the HTTP request that initiated the session, information about the browser and the current URL and more.
 
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
@@ -36,4 +36,4 @@ How to access the busy state.
 request
 url
 busy
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/state/request.md b/doc/how_to/state/request.md
index 15df1988f7..ab71caeaa7 100644
--- a/doc/how_to/state/request.md
+++ b/doc/how_to/state/request.md
@@ -13,7 +13,7 @@ except Exception:
     phase = 1
 ```
 
-This mechanism may be used to modify the behavior of an app dependending on parameters provided in the URL. 
+This mechanism may be used to modify the behavior of an app dependending on parameters provided in the URL.
 
 ## Cookies
 
diff --git a/doc/how_to/state/url.md b/doc/how_to/state/url.md
index c1c5a14ce2..e8e7b351fc 100644
--- a/doc/how_to/state/url.md
+++ b/doc/how_to/state/url.md
@@ -14,7 +14,7 @@ When starting a server session Panel will attach a `Location` component which ca
 * **``search``** (string): search part of the url e.g. '?color=blue'.
 * **``hash_``** (string): hash part of the url e.g. '#interact'.
 * **``reload``** (bool): Whether or not to reload the page when the url is updated.
-    - For independent apps this should be set to True. 
+    - For independent apps this should be set to True.
     - For integrated or single page apps this should be set to False.
 
 ### Readonly
@@ -34,9 +34,9 @@ import param
 import panel as pn
 
 class QueryExample(param.Parameterized):
-    
+
     integer = param.Integer(default=None, bounds=(0, 10))
-    
+
     string = param.String(default='A string')
 ```
 
diff --git a/doc/how_to/wasm/index.md b/doc/how_to/wasm/index.md
index d754ffc8a4..d381ca9d0d 100644
--- a/doc/how_to/wasm/index.md
+++ b/doc/how_to/wasm/index.md
@@ -34,14 +34,14 @@ Discover how to set up and use Panel from Pyodide and PyScript.
 :link: user_info
 :link-type: doc
 
-Discover how to integrate live Panel components in your Sphinx based documentation. 
+Discover how to integrate live Panel components in your Sphinx based documentation.
 :::
 
 :::{grid-item-card} {octicon}`zap;2.5em;sd-mr-1` JupyterLite
 :link: jupyterlite
 :link-type: doc
 
-Discover how to set up a JupyterLite deployment capable of rendering interactive Panel output. 
+Discover how to set up a JupyterLite deployment capable of rendering interactive Panel output.
 :::
 
 ::::

From 9e9d92897b98b708d80ef7f5a55bb1af20aa4189 Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Wed, 4 Jan 2023 12:13:18 +0100
Subject: [PATCH 05/15] Add logos

---
 doc/_static/logos/azure.png       | Bin 0 -> 19567 bytes
 doc/_static/logos/binder.png      | Bin 0 -> 29485 bytes
 doc/_static/logos/django.png      | Bin 0 -> 15109 bytes
 doc/_static/logos/fastapi.png     | Bin 0 -> 5394 bytes
 doc/_static/logos/flask.png       | Bin 0 -> 31518 bytes
 doc/_static/logos/gcp.png         | Bin 0 -> 14852 bytes
 doc/_static/logos/heroku.png      | Bin 0 -> 9725 bytes
 doc/_static/logos/huggingface.png | Bin 0 -> 24470 bytes
 doc/how_to/deployment/index.md    |  12 +++++++++++-
 doc/how_to/display/index.md       |   1 +
 doc/how_to/integrations/index.md  |   6 ++++++
 doc/how_to/server/index.md        |   4 ++--
 doc/how_to/state/index.md         |   6 +++---
 13 files changed, 23 insertions(+), 6 deletions(-)
 create mode 100644 doc/_static/logos/azure.png
 create mode 100644 doc/_static/logos/binder.png
 create mode 100644 doc/_static/logos/django.png
 create mode 100644 doc/_static/logos/fastapi.png
 create mode 100644 doc/_static/logos/flask.png
 create mode 100644 doc/_static/logos/gcp.png
 create mode 100644 doc/_static/logos/heroku.png
 create mode 100644 doc/_static/logos/huggingface.png

diff --git a/doc/_static/logos/azure.png b/doc/_static/logos/azure.png
new file mode 100644
index 0000000000000000000000000000000000000000..5f2018c3025f86e70d48ad966a9ea49c3b7852ba
GIT binary patch
literal 19567
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

literal 0
HcmV?d00001

diff --git a/doc/_static/logos/binder.png b/doc/_static/logos/binder.png
new file mode 100644
index 0000000000000000000000000000000000000000..3071dde09bd3286ce22f7a9003ffb3ee55ff32e9
GIT binary patch
literal 29485
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

literal 0
HcmV?d00001

diff --git a/doc/_static/logos/django.png b/doc/_static/logos/django.png
new file mode 100644
index 0000000000000000000000000000000000000000..aa33958926aa37b10eebd09fc872f7891fb1c4e2
GIT binary patch
literal 15109
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
P6`&xaDqa84JoNtnEKtuJ

literal 0
HcmV?d00001

diff --git a/doc/_static/logos/fastapi.png b/doc/_static/logos/fastapi.png
new file mode 100644
index 0000000000000000000000000000000000000000..0649ddc6d1886668fea7393faab576a9e33b4551
GIT binary patch
literal 5394
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

literal 0
HcmV?d00001

diff --git a/doc/_static/logos/flask.png b/doc/_static/logos/flask.png
new file mode 100644
index 0000000000000000000000000000000000000000..5fce622ba50cc2193ad92ee6b800583b10ea7328
GIT binary patch
literal 31518
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
z%0D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

literal 0
HcmV?d00001

diff --git a/doc/_static/logos/gcp.png b/doc/_static/logos/gcp.png
new file mode 100644
index 0000000000000000000000000000000000000000..d5457535a8fffa941b206309dbb47988da565f0e
GIT binary patch
literal 14852
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

literal 0
HcmV?d00001

diff --git a/doc/_static/logos/heroku.png b/doc/_static/logos/heroku.png
new file mode 100644
index 0000000000000000000000000000000000000000..7ac327b2c030930bc9a847d2483197b67ff0fd93
GIT binary patch
literal 9725
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
UT3ZdoV_g7!q@hlwmVNa90?wTXBLDyZ

literal 0
HcmV?d00001

diff --git a/doc/_static/logos/huggingface.png b/doc/_static/logos/huggingface.png
new file mode 100644
index 0000000000000000000000000000000000000000..cba7ba1bf41c1b4d880dc3b19a7fcb4675f8302d
GIT binary patch
literal 24470
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
EKi&zla{vGU

literal 0
HcmV?d00001

diff --git a/doc/how_to/deployment/index.md b/doc/how_to/deployment/index.md
index 605fcf4f6a..e922dc3f52 100644
--- a/doc/how_to/deployment/index.md
+++ b/doc/how_to/deployment/index.md
@@ -10,26 +10,36 @@ For guides on running and configuring a Panel server see the [server how-to guid
 :::{grid-item-card} Azure
 :link: azure
 :link-type: doc
+
+![Azure Logo](../../_static/logos/azure.png)
 :::
 
 :::{grid-item-card} Binder
 :link: binder
 :link-type: doc
+
+![Binder Logo](../../_static/logos/binder.png)
 :::
 
-:::{grid-item-card} Google Cloud
+:::{grid-item-card} Google Cloud Platform
 :link: gcp
 :link-type: doc
+
+![GCP Logo](../../_static/logos/gcp.png)
 :::
 
 :::{grid-item-card} Heroku
 :link: heroku
 :link-type: doc
+
+![Heroku Logo](../../_static/logos/heroku.png)
 :::
 
 :::{grid-item-card} Hugging Face
 :link: huggingface
 :link-type: doc
+
+![Hugging Face Logo](../../_static/logos/huggingface.png)
 :::
 
 ::::
diff --git a/doc/how_to/display/index.md b/doc/how_to/display/index.md
index e69de29bb2..92af613dc0 100644
--- a/doc/how_to/display/index.md
+++ b/doc/how_to/display/index.md
@@ -0,0 +1 @@
+# Display and Preview Output
diff --git a/doc/how_to/integrations/index.md b/doc/how_to/integrations/index.md
index a0f435047c..cfc75c4b7a 100644
--- a/doc/how_to/integrations/index.md
+++ b/doc/how_to/integrations/index.md
@@ -10,6 +10,8 @@ These guides will cover how to integrate Panel applications with various externa
 :link-type: doc
 
 Discover to run Panel applications alongside an existing Flask server.
+
+![Flask Logo](../../_static/logos/flask.png)
 :::
 
 :::{grid-item-card} FastAPI
@@ -17,6 +19,8 @@ Discover to run Panel applications alongside an existing Flask server.
 :link-type: doc
 
 Discover to run Panel applications alongside an existing FastAPI server.
+
+![FastAPI Logo](../../_static/logos/fastapi.png)
 :::
 
 :::{grid-item-card} Django
@@ -24,6 +28,8 @@ Discover to run Panel applications alongside an existing FastAPI server.
 :link-type: doc
 
 Discover to run Panel applications on a Django server (replacing the standard Tornado based server).
+
+![Django Logo](../../_static/logos/django.png)
 :::
 
 ::::
diff --git a/doc/how_to/server/index.md b/doc/how_to/server/index.md
index dba34970c8..314b61a208 100644
--- a/doc/how_to/server/index.md
+++ b/doc/how_to/server/index.md
@@ -19,14 +19,14 @@ If you do not want to maintain your own web server and/or set up complex reverse
 :link: commandline
 :link-type: doc
 
-Launch and configure a Panel application from the commandline.
+Discover how to launch and configure a Panel application from the commandline.
 :::
 
 :::{grid-item-card} {octicon}`code-square;2.5em;sd-mr-1` Launch programmatically
 :link: programmatic
 :link-type: doc
 
-Launch and configure a Panel application programmatically.
+Discover how to launch and configure a Panel application programmatically.
 :::
 
 :::{grid-item-card} {octicon}`stack;2.5em;sd-mr-1` Serving multiple applications
diff --git a/doc/how_to/state/index.md b/doc/how_to/state/index.md
index ec0befcbb7..5a86a10834 100644
--- a/doc/how_to/state/index.md
+++ b/doc/how_to/state/index.md
@@ -6,20 +6,20 @@ Whenever a Panel application is being served the `panel.state` object will provi
 :gutter: 1 1 1 2
 
 :::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` HTTP Request
-:link: manual
+:link: request
 :link-type: doc
 
 How to access information about the HTTP request associated with a session.
 :::
 
-:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` url
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` URL state
 :link: url
 :link-type: doc
 
 How to access and manipulate the URL.
 :::
 
-:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` busy
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` Busyiness state
 :link: busy
 :link-type: doc
 

From 36cf764285d5f3407aec2e116065f420029ca88a Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Wed, 4 Jan 2023 14:31:09 +0100
Subject: [PATCH 06/15] Convert Links, Param and API user guides into how-to
 guides

---
 doc/_static/logos/django.png     | Bin 15109 -> 7694 bytes
 doc/_static/logos/fastapi.png    | Bin 5394 -> 8042 bytes
 doc/_static/logos/flask.png      | Bin 31518 -> 12465 bytes
 doc/how_to/apis/callbacks.md     |  43 ++++
 doc/how_to/apis/index.md         |  54 +++++
 doc/how_to/apis/interact.md      |  55 +++++
 doc/how_to/apis/parameterized.md |  45 ++++
 doc/how_to/apis/reactive.md      |  80 +++++++
 doc/how_to/index.md              |  52 ++++-
 doc/how_to/links/index.md        |  63 ++++++
 doc/how_to/links/jscallbacks.md  |  22 ++
 doc/how_to/links/jslinks.md      |  73 +++++++
 doc/how_to/links/link_plots.md   |  56 +++++
 doc/how_to/links/links.md        |  48 +++++
 doc/how_to/links/watchers.md     |  76 +++++++
 doc/how_to/param/custom.md       |  68 ++++++
 doc/how_to/param/dependencies.md |  73 +++++++
 doc/how_to/param/index.md        |  50 +++++
 doc/how_to/param/subobjects.md   |  99 +++++++++
 doc/how_to/param/uis.md          |  90 ++++++++
 doc/user_guide/APIs.md           | 212 ------------------
 doc/user_guide/Links.md          | 306 --------------------------
 doc/user_guide/Param.md          | 359 -------------------------------
 doc/user_guide/index.rst         |   9 -
 24 files changed, 1046 insertions(+), 887 deletions(-)
 create mode 100644 doc/how_to/apis/callbacks.md
 create mode 100644 doc/how_to/apis/index.md
 create mode 100644 doc/how_to/apis/interact.md
 create mode 100644 doc/how_to/apis/parameterized.md
 create mode 100644 doc/how_to/apis/reactive.md
 create mode 100644 doc/how_to/links/index.md
 create mode 100644 doc/how_to/links/jscallbacks.md
 create mode 100644 doc/how_to/links/jslinks.md
 create mode 100644 doc/how_to/links/link_plots.md
 create mode 100644 doc/how_to/links/links.md
 create mode 100644 doc/how_to/links/watchers.md
 create mode 100644 doc/how_to/param/custom.md
 create mode 100644 doc/how_to/param/dependencies.md
 create mode 100644 doc/how_to/param/index.md
 create mode 100644 doc/how_to/param/subobjects.md
 create mode 100644 doc/how_to/param/uis.md
 delete mode 100644 doc/user_guide/APIs.md
 delete mode 100644 doc/user_guide/Links.md
 delete mode 100644 doc/user_guide/Param.md

diff --git a/doc/_static/logos/django.png b/doc/_static/logos/django.png
index aa33958926aa37b10eebd09fc872f7891fb1c4e2..0330cb56b75ee51c80258ead7c5eba78171b69b8 100644
GIT binary patch
literal 7694
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
IM6N<$f?d@2=Kufz

literal 15109
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
P6`&xaDqa84JoNtnEKtuJ

diff --git a/doc/_static/logos/fastapi.png b/doc/_static/logos/fastapi.png
index 0649ddc6d1886668fea7393faab576a9e33b4551..dade0cbbcc2ff13a54b151b0106754adc15d757a 100644
GIT binary patch
literal 8042
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

literal 5394
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

diff --git a/doc/_static/logos/flask.png b/doc/_static/logos/flask.png
index 5fce622ba50cc2193ad92ee6b800583b10ea7328..78f25e58d765372732cdffade74a24466678dbcf 100644
GIT binary patch
literal 12465
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

literal 31518
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
z%0D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

diff --git a/doc/how_to/apis/callbacks.md b/doc/how_to/apis/callbacks.md
new file mode 100644
index 0000000000..2cdb16f72e
--- /dev/null
+++ b/doc/how_to/apis/callbacks.md
@@ -0,0 +1,43 @@
+# Callbacks
+
+The callback API in Panel is the lowest-level approach, affording the greatest amount of flexibility but also quickly growing in complexity because each new interactive behavior requires additional callbacks that can interact in complex ways. Nonetheless, callbacks are important to know about, and can often be used to complement the other approaches. For instance, one specific callback could be used in addition to the more reactive approaches the other APIs provide.
+
+For more details on defining callbacks see the [Links user guide](./Links.md).
+
+## Pros:
+
++ Complete and modular control over specific events
+
+## Cons:
+
+- Complexity grows very quickly with the number of callbacks
+- Have to handle initializing the plots separately
+
+## Example
+
+In this approach we once again define the widgets. Unlike in other approaches we then have to define the actual layout, to ensure that the callback we define has something that it can update or replace. In this case we use a single callback to update the plot, but in many cases multiple callbacks might be required.
+
+```{pyodide}
+import hvplot.pandas
+
+from bokeh.sampledata.autompg import autompg
+
+columns = list(autompg.columns[:-2])
+
+x = pn.widgets.Select(value='mpg', options=columns, name='x')
+y = pn.widgets.Select(value='hp', options=columns, name='y')
+color = pn.widgets.ColorPicker(name='Color', value='#880588')
+
+layout = pn.Row(
+    pn.Column('## MPG Explorer', x, y, color),
+    autompg_plot(x.value, y.value, color.value))
+
+def update(event):
+    layout[1].object = autompg_plot(x.value, y.value, color.value)
+
+x.param.watch(update, 'value')
+y.param.watch(update, 'value')
+color.param.watch(update, 'value')
+
+layout
+```
\ No newline at end of file
diff --git a/doc/how_to/apis/index.md b/doc/how_to/apis/index.md
new file mode 100644
index 0000000000..45ab75e002
--- /dev/null
+++ b/doc/how_to/apis/index.md
@@ -0,0 +1,54 @@
+# APIs
+
+Panel can be used to make a first pass at an app or dashboard in minutes, while also allowing you to fully customize the app's behavior and appearance or flexibly integrate GUI support into long-term, large-scale software projects. To accommodate these different ways of using Panel, four different APIs are available:
+
+::::{grid} 1 2 2 4
+:gutter: 1 1 1 2
+
+:::{grid-item-card} Reactive Functions
+:link: reactive
+:link-type: doc
+
+Linking functions or methods to widgets using ``pn.bind`` or the equivalent ``pn.depends`` decorator, declaring that the function should be re-run when those widget values change.
+:::
+
+:::{grid-item-card} Interact functions
+:link: interact
+:link-type: doc
+
+Auto-generates a full UI (including widgets) given a function.
+:::
+
+:::{grid-item-card} Parameterized class
+:link: parameterized
+:link-type: doc
+
+Declare parameters and their ranges in `Parameterized` classes, then get GUIs (and value checking!) for free.
+:::
+
+
+:::{grid-item-card} Callbacks
+:link: callbacks
+:link-type: doc
+
+Generate a UI by manually declaring callbacks that update panels or panes.
+:::
+
+::::
+
+Each of these APIs has its own benefits and drawbacks, so this section will go through each one in turn, while working through an example app and pointing out the benefits and drawback along the way. For a quick overview you can also review the API gallery examples, e.g. the [stocks_hvplot](../../gallery/apis/stocks_hvplot.ipynb) app.
+
+As you will discover, each of these four APIs allows building the same basic application. The choice of the appropriate API depends very much on the use case. To build a quick throwaway GUI the ``interact`` approach can be completely sufficient. A much more explicit, flexible, and maintainable version of that approach is to define a reactive function that is bound directly to a set of widgets using `pn.bind`. When writing libraries or other code that might be used independently of the actual GUI, a Parameterized class can be a great way to organize the code.
+
+Finally, if you need low-level control or want to complement any of the other approaches, defining explicit callbacks can be the best approach. Nearly all of the functionality of Panel can be accessed using any of the APIs, but each makes certain things much easier than others. Choosing the API is therefore a matter of considering the tradeoffs and of course also a matter of preference. If you still aren't sure after reading the above, then just go with the `pn.bind` reactive API!
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+reactive
+interact
+parameterized
+callbacks
+```
diff --git a/doc/how_to/apis/interact.md b/doc/how_to/apis/interact.md
new file mode 100644
index 0000000000..85c85779fb
--- /dev/null
+++ b/doc/how_to/apis/interact.md
@@ -0,0 +1,55 @@
+# Interact Functions
+
+The ``interact`` function will automatically generate a UI (including widgets) by inspecting the arguments of the function given to it, or by using additional hints you provide in the ``interact`` function call. If you have worked with the [``ipywidgets``](https://github.com/jupyter-widgets/ipywidgets) package you may already be familiar with this approach. (In fact, the Panel interact function is modeled on the one from ipywidgets, making it simpler to port code between the two platforms.) The basic idea is that given a function that returns some object, Panel will inspect the arguments to that function, try to infer appropriate widgets for those arguments, and then re-run that function to update the output whenever one of the widgets generates an event. For more detail on how interact creates widgets and other ways of using it, see the Panel [interact user guide](./Interact.md).  This section instead focuses on when and why to use this API, laying out its benefits and drawbacks.
+
+The main benefit of this approach is convenience and ease of use.  You start by writing some function that returns an object, be that a plot, a dataframe, or anything else that Panel can render. Then with a single call to `pn.interact()`, you can immediately get an interactive UI, without ever instantiating any widgets or wiring up any callbacks explicitly. Unlike ipywidgets, the ``pn.interact`` call will return a Panel. This Panel can then be further modified by laying out the widgets and output separately, or combining these components with other panes. Even though `pn.interact` itself is limited in flexibility compared to the rest of Panel, you can still unpack and reconfigure the results from it to generate fairly complex GUIs in very little code.
+
+## Pros:
+
++ Easy to use (or at least easy to get started!).
++ Doesn't typically require modifying existing visualization code.
+
+## Cons:
+
+- Most of the behavior is implicit, with magic happening by introspection, making it difficult to see how to modify the appearance or functionality of the resulting object.
+- Customizing the layout requires indexing into the panel returned by `interact`.
+
+## Explanation
+
+The magic of the `interact` API derives from the fact that it inspects the signature of a function and/or the arguments passed to `interact` and automatically generates widgets appropriate for controlling those arguments.
+
+As an example let us declare a simple function that returns the arguments formatted as a string. If we pass in an integer for argument `a` and a string for argument `b` it will generate a slider and string input widget for each argument respectively:
+
+```{pyodide}
+import panel as pn
+pn.extension()
+
+def fn(a, b):
+    return f'Arguments: {a,b}'
+
+pn.interact(fn, a=1, b='string')
+```
+
+This makes it very powerful for quickly making a function interactive but the behavior is very implicit and a more declarative approach is usually preferable for most usecases.
+
+## Example
+
+The simplest `interact` call can be a one-liner, but here we'll show an example of intermediate complexity so that you get a good idea of what `interact` can do in practice. In this code, ``pn.interact`` infers the initial value for `x` and `y` from the `autompg_plot` function default arguments and their widget type and range from the `columns` list provided to `interact`. `interact` wouldn't normally put up a color widget because it would have no way of knowing that this string-type argument represents an RGB color, and so here we explicitly create a color-picker widget and pass that as the value for the color so that we can control the color as well.
+
+Finally, we unpack the result from `interact` and rearrange it in a different layout with a title, to create the final app. See the Panel [interact user guide](./Interact.md) for even simpler examples along with details about how to control the widgets and how to rearrange the layout.
+
+```{pyodide}
+import hvplot.pandas
+
+from bokeh.sampledata.autompg import autompg
+
+def autompg_plot(x='mpg', y='hp', color='#058805'):
+    return autompg.hvplot.scatter(x, y, c=color, padding=0.1)
+
+columns = list(autompg.columns[:-2])
+
+color = pn.widgets.ColorPicker(name='Color', value='#4f4fdf')
+layout = pn.interact(autompg_plot, x=columns, y=columns, color=color)
+
+pn.Row(pn.Column('## MPG Explorer', layout[0]), layout[1])
+```
\ No newline at end of file
diff --git a/doc/how_to/apis/parameterized.md b/doc/how_to/apis/parameterized.md
new file mode 100644
index 0000000000..1e2ef56293
--- /dev/null
+++ b/doc/how_to/apis/parameterized.md
@@ -0,0 +1,45 @@
+# Parameterized Classes
+
+The [Param](http://param.holoviz.org) library allows expressing the parameters of a class (or a hierarchy of classes) completely independently of a GUI implementation. Panel and other libraries can then take those parameter declarations and turn them into a GUI to control the parameters. This approach allows the parameters controlling some computation to be captured specifically and explicitly (but as abstract parameters, not as widgets). Then thanks to the `@param.depends` decorator (similar to `@panel.depends` but for use in Parameterized classes without any dependency on Panel), it is then possible to directly express the dependencies between the parameters and the computation defined in some method on the class, all without ever importing Panel or any other GUI library. The resulting objects can then be used in both GUI and non-GUI contexts (batch computations, scripts, servers).
+
+The parameterized approach is a powerful way to encapsulate computation in self-contained classes, taking advantage of object-oriented programming patterns. It also makes it possible to express a problem completely independently from Panel or any other GUI code, while still getting a GUI for free as a last step. For more detail on using this approach see the [Param user guide](../user_guide/Param).
+
+## Pros:
+
++ Declarative way of expressing parameters and dependencies between parameters and computation
++ The resulting code is not tied to any particular GUI framework and can be used in other contexts as well
+
+## Cons:
+
+- Requires writing classes
+- Less explicit about widgets to use for each parameter; can be harder to customize behavior than if widgets are instantiated explicitly
+
+## Explanation
+
+In this model we declare a subclass of ``param.Parameterized``, declare the parameters we want at the class level, make an instance of the class, and finally lay out the parameters and plot method of the class.
+
+## Example
+
+```{pyodide}
+import hvplot.pandas
+import panel as pn
+import param
+
+from bokeh.sampledata.autompg import autompg
+
+columns = list(autompg.columns[:-2])
+
+class MPGExplorer(param.Parameterized):
+
+    x = param.Selector(objects=columns)
+    y = param.Selector(default='hp', objects=columns)
+    color = param.Color(default='#0f0f0f')
+
+    @param.depends('x', 'y', 'color') # optional in this case
+    def plot(self):
+        return autompg.hvplot.scatter(x, y, c=color, padding=0.1)
+
+explorer = MPGExplorer()
+
+pn.Row(explorer.param, explorer.plot)
+```
\ No newline at end of file
diff --git a/doc/how_to/apis/reactive.md b/doc/how_to/apis/reactive.md
new file mode 100644
index 0000000000..6c2bb3d02c
--- /dev/null
+++ b/doc/how_to/apis/reactive.md
@@ -0,0 +1,80 @@
+# Reactive functions
+
+The `pn.bind` reactive programming API is very similar to the [`interact` function](interact) but is more explicit about widget selection and layout. `pn.bind` requires the programmer to select and configure widgets explicity and to lay out components explicitly, without relying on inference of widget types and ranges and without any default layouts. Specifying those aspects explicitly provides more power and control, but does typically take a bit more code and more knowledge of widget and layout components than using `interact` does. Once widgets have been bound to a reactive function, you can lay out the bound function and the widgets in any order or combination you like, including across Jupyter notebook cells if desired.
+
+## Pros:
+
++ Very clear mapping from widgets to the arguments of the function.
++ Very explicit layout of each of the different components.
++ Like `interact`, doesn't typically require modifying existing visualization code.
+
+## Cons:
+
+- Typically requires a bit more code than `interact`
+
+## Explanation
+
+In this model, we can use an existing plotting function just as for `interact`, but then need to declare each widget explicitly and then bind a widget to each of the arguments that we want to be interactive. The `pn.bind` function works much like [`functools.partial`](https://docs.python.org/3/library/functools.html#functools.partial) in that it binds regular arguments and keyword arguments to a function. `partial` can only bind specific, static arguments like `5`, but `pn.bind` can also bind parameters, widgets, and other dynamic functions with dependencies to the arguments, ensuring when the function is called the current values of the parameters are passed to the function. A bound function is then reactive, updating whenever the widget values change.
+
+To make the concept of binding clear, let's look at a trivial example first:
+
+```{pyodide}
+import panel as pn
+pn.extension()
+
+def fn(a,b): return f'Arguments: {a,b}'
+slider = pn.widgets.FloatSlider(value=0.5)
+
+bound_fn = pn.bind(fn, a=slider, b=2)
+bound_fn()
+```
+
+Here we can see that although `fn` required two arguments, `bound_fn` takes no arguments because `a` has been bound to the slider value and `b` to a static value.
+
+If we display the slider and bound function in Panel, we can see that everything will update reactively as you use the widget, reevaluating the function whenever the bound argument changes:
+
+```{pyodide}
+pn.Row(slider, bound_fn)
+```
+
+## Example
+
+Now let us create a simple application with some more interesting output. Just like in the [other API examples](index) we will load the AutoMPG dataset and let you pick the axes to plot and how to color the scatter plot. Using the `pn.bind` function, we can easily add the interactivity by binding widgets to each argument and lay out the result with the widgets:
+
+```{pyodide}
+import hvplot.pandas
+
+from bokeh.sampledata.autompg import autompg
+
+columns = list(autompg.columns[:-2])
+
+x = pn.widgets.Select(value='mpg', options=columns, name='x')
+y = pn.widgets.Select(value='hp', options=columns, name='y')
+color = pn.widgets.ColorPicker(name='Color', value='#AA0505')
+
+pn.Row(
+    pn.Column('## MPG Explorer', x, y, color),
+    pn.bind(autompg.hvplot.scatter, x, y, c=color)
+)
+```
+
+Notice how here we didn't even need the `autompg_plot` function here, because `bind` works with both methods and functions, so for this particular case the reactive API works out to the same amount of code as the [`interact`](interact) API.
+
+If you are writing code specifically for building an app, and do not wish to keep domain and GUI code separate, the functionality of `pn.bind` is also available as a decorator `@pn.depends`:
+
+```{pyodide}
+x = pn.widgets.Select(value='mpg', options=columns, name='x')
+y = pn.widgets.Select(value='hp', options=columns, name='y')
+color = pn.widgets.ColorPicker(name='Color', value='#AA0505')
+
+@pn.depends(x, y, color)
+def plot(xval, yval, colorval):
+    return autompg.hvplot.scatter(xval, yval, c=colorval)
+
+pn.Row(
+    pn.Column('## MPG Explorer', x, y, color),
+    plot
+)
+```
+
+This alternative way of specifying the same app lets you declare the dependency between a function argument and a widget (or parameter) from the start, which can be clearer if you know the function will always and only be used in a GUI. Otherwise, the `pn.bind` version is preferred, because it allows you to keep the Panel-specific code separate (even in a different Python module or file) from the underlying analysis and plotting code.
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index b0d194dcfb..41506ca33c 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -2,10 +2,41 @@
 
 The Panel's How to Guides provide step by step recipes for solving essential problems and tasks. They are more advanced than the Getting Started material and assume some knowledge of how Panel works.
 
+## Basics
+
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
-:::{grid-item-card} {octicon}`note;2.5em;sd-mr-1` Session callbacks and events
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` APIs
+:link: apis/index
+:link-type: doc
+
+Discover the different APIs offered by Panel.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Parameters
+:link: param/index
+:link-type: doc
+
+Discover how to use Parameters with Panel.
+:::
+
+:::{grid-item-card} {octicon}`link;2.5em;sd-mr-1` Linking Parameters
+:link: links/index
+:link-type: doc
+
+Discover different ways of linking parameters in Python and Javascript.
+:::
+
+::::
+
+
+## Advanced
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`zap;2.5em;sd-mr-1` Session callbacks and events
 :link: callbacks/index
 :link-type: doc
 
@@ -26,6 +57,14 @@ How to access state related to the user session, HTTP request and URL arguments.
 How to cache data across sessions and memoize the output of functions.
 :::
 
+::::
+
+
+## Display and Export
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
 :::{grid-item-card} {octicon}`device-desktop;2.5em;sd-mr-1` Display and Preview output
 :link: display/index
 :link-type: doc
@@ -47,6 +86,14 @@ How to export and save Panel applications as static files.
 How to run Panel applications entirely in the browser using WebAssembly, Pyodide and PyScript.
 :::
 
+::::
+
+
+## Server configuration and deployment 
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
 :::{grid-item-card} {octicon}`server;2.5em;sd-mr-1` Server Configuration
 :link: server/index
 :link-type: doc
@@ -77,11 +124,14 @@ How to configure OAuth to add authentication to a server deployment.
 
 ::::
 
+
 ```{toctree}
 :titlesonly:
 :hidden:
 :maxdepth: 2
 
+apis/index
+links/index
 callbacks/index
 state/index
 caching/index
diff --git a/doc/how_to/links/index.md b/doc/how_to/links/index.md
new file mode 100644
index 0000000000..78af46656f
--- /dev/null
+++ b/doc/how_to/links/index.md
@@ -0,0 +1,63 @@
+# Linking parameters
+
+In the [Param how-to guide](../param/index), we have seen how Parameterized classes can be used to automatically generate a graphical user interface for Python code without any additional effort. If you need full control over how your GUI is set up, you can instead manually define widgets linking directly to other objects using either Python or JavaScript (JS) callbacks. Python callbacks are simple for Python users to write and can directly access Python data structures, while JS callbacks can directly manipulate the displayed HTML document and allow setting up dynamic behavior even for exported HTML files (with no Python process running).
+
+Here we will show how to link parameters of Panel objects, typically from widgets to other objects. To do this, we will introduce three API calls:
+
+* ``obj.link``: 
+* ``obj.param.watch``: 
+* ``obj.jslink``: high-level API to link objects via JS code
+* ``obj.jscallback``: a lower-level API to define arbitrary Javascript callbacks
+
+::::{grid} 1 2 2 4
+:gutter: 1 1 1 2
+
+:::{grid-item-card} Watchers
+:link: watchers
+:link-type: doc
+
+Discover how to use the powerful but low-level `.param.watch` API provided by [param](https://param.pyviz.org) to trigger callbacks on parameters.
+:::
+
+:::{grid-item-card} Links in Python
+:link: links
+:link-type: doc
+
+Discover how to use the convenient, high-level `.link` API to link parameters in Python.
+:::
+
+:::{grid-item-card} Links in Javascript
+:link: jslinks
+:link-type: doc
+
+Discover how to use the convenient, high-level `.jslink` API to link parameters in Javascript.
+:::
+
+:::{grid-item-card} Link plots in Javascript
+:link: jslinks
+:link-type: doc
+
+Discover how to use `.jslink` to link Bokeh and HoloViews plot parameters in Javascript.
+:::
+
+:::{grid-item-card} Javascript callbacks
+:link: jscallbacks
+:link-type: doc
+
+Discover how to use the `.jscallback` API to write arbitrary JS callbacks linking one or more components.
+:::
+
+::::
+
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+watchers
+links
+jslinks
+link_plots
+jscallback
+```
\ No newline at end of file
diff --git a/doc/how_to/links/jscallbacks.md b/doc/how_to/links/jscallbacks.md
new file mode 100644
index 0000000000..3dd9609582
--- /dev/null
+++ b/doc/how_to/links/jscallbacks.md
@@ -0,0 +1,22 @@
+# Defining Javascript callbacks
+
+Sometimes defining a simple link between to objects is not sufficient, e.g. when there are a number of objects involved. In these cases it is helpful to be able to define arbitrary Javascript callbacks. A very simple example is a very basic calculator which allows multiplying or adding two values, in this case we have two widgets to input numbers, a selector to pick the operation, a display for the result and a button.
+
+To implement this we define a `jscallback`, which is triggered when the `Button.clicks` property changes and provide a number of `args` allowing us to access the values of the various widgets:
+
+```{pyodide}
+value1 =   pn.widgets.Spinner(value=0, width=75)
+operator = pn.widgets.Select(value='*', options=['*', '+'], width=50, align='center')
+value2 =   pn.widgets.Spinner(value=0, width=75)
+button =   pn.widgets.Button(name='=', width=50)
+result =   pn.widgets.StaticText(value='0', width=50, align='center')
+
+button.jscallback(clicks="""
+if (op.value == '*')
+  result.text = (v1.value * v2.value).toString()
+else
+  result.text = (v1.value + v2.value).toString()
+""", args={'op': operator, 'result': result, 'v1': value1, 'v2': value2})
+
+pn.Row(value1, operator, value2, button, result)
+```
diff --git a/doc/how_to/links/jslinks.md b/doc/how_to/links/jslinks.md
new file mode 100644
index 0000000000..1de17cd434
--- /dev/null
+++ b/doc/how_to/links/jslinks.md
@@ -0,0 +1,73 @@
+# Linking parameters in JS
+
+Linking objects in Python is often very convenient, because it allows writing code entirely in Python. However, it also requires a live Python kernel. If instead we want a static example (e.g. on a simple website or in an email) to have custom interactivity, or we simply want to avoid the overhead of having to call back into Python, we can define links in JavaScript.
+
+To begin with let us see how we can express simple links between standard Panel components before digging into some more specific and complex examples.
+
+### Linking model properties
+
+Let us start by rehashing the example from above, linking the ``value`` of the ``TextInput`` widget to the ``object`` property of the ``Markdown`` pane:
+
+```{pyodide}
+import panel as pn
+
+markdown = pn.pane.Markdown('Markdown display')
+text_input = pn.widgets.TextInput(value=markdown.object)
+
+link = text_input.jslink(markdown, value='object')
+
+pn.Row(text_input, markdown)
+```
+
+As you can see the signature is identical to the ``link`` example above, but here Panel translates the specification into a JS code snippet which syncs the properties on the underlying Bokeh properties. But now if you edit the widget and press Return, the Markdown display will automatically update even in a static HTML web page.
+
+### Linking bi-directionally
+
+When you want the source and target to be linked bi-directionally, i.e. a change in one will automatically trigger a change in the other you can simply set the `bidirectional` argument:
+
+
+```{pyodide}
+t1 = pn.widgets.TextInput()
+t2 = pn.widgets.TextInput()
+
+t1.jslink(t2, value='value', bidirectional=True)
+
+pn.Row(t1, t2)
+```
+
+### Linking using custom JS code
+
+Since everything happens in JS for a `jslink`, we can't provide a Python callback. Instead, we can define a JS code snippet, which is executed when a property changes. E.g. we can define a little code snippet which adds HTML bold tags (``<b>``) around the text before setting it on the target. The code argument should map from the parameter/property on the source object to the JS code snippet to execute:
+
+
+```{pyodide}
+markdown = pn.pane.Markdown("<b>Markdown display</b>", width=400)
+text_input = pn.widgets.TextInput(value="Markdown display")
+
+code = '''
+    target.text = '<b>' + source.value + '</b>'
+'''
+link = text_input.jslink(markdown, code={'value': code})
+
+pn.Row(text_input, markdown)
+```
+
+Here ``source`` and ``target`` are made available in the JavaScript namespace, allowing us to arbitrarily modify the models in response to property change events. Note however that the underlying Bokeh model property names may differ slightly from the naming of the parameters on Panel objects, e.g. the 'object' parameter on the Markdown pane translates to the 'text' property on the Bokeh model used to render the ``Markdown``.
+
+Of course, you can still update the value from Python, and it will automatically update the linked markdown:
+
+
+```{pyodide}
+text_input.value = "Markdown display"
+```
+
+### Open URL
+
+As an example of using `jslink`, here we open a URL from the ``TextInput`` widget value. A new browser tab will open with the provided URL:
+
+```{pyodide}
+button = pn.widgets.Button(name='Open URL', button_type = 'primary')
+url = pn.widgets.TextInput(name='URL', value = 'https://pyviz.org/')
+button.js_on_click(args={'target': url}, code='window.open(target.value)')
+pn.Row(url, button)
+```
diff --git a/doc/how_to/links/link_plots.md b/doc/how_to/links/link_plots.md
new file mode 100644
index 0000000000..04fe7528d8
--- /dev/null
+++ b/doc/how_to/links/link_plots.md
@@ -0,0 +1,56 @@
+# Linking Plots in Javascript
+
+The [guide to linking in Javascript](jslinks) demonstrated how to link simple static panes, but links are probably most useful when combined with dynamic objects like plots.
+
+## Bokeh
+
+The ``jslink`` API trivially allows us to link a parameter on a Panel widget to a Bokeh plot property. Here we create a Bokeh Figure with a simple sine curve. The ``jslink`` method allows us to pass any Bokeh model held by the Figure as the ``target``, then link the widget value to some property on it. E.g. here we link a ``FloatSlider`` value to the ``line_width`` of the ``Line`` glyph:
+
+```{pyodide}
+import numpy as np
+import panel as pn
+
+from bokeh.plotting import figure
+
+p = figure(width=300, height=300)
+xs = np.linspace(0, 10)
+r = p.line(xs, np.sin(xs))
+
+width_slider = pn.widgets.FloatSlider(name='Line Width', start=0.1, end=10)
+width_slider.jslink(r.glyph, value='line_width')
+
+pn.Column(width_slider, p)
+```
+
+## HoloViews
+
+Bokeh models allow us to directly access the underlying models and properties, but this access is more indirect when working with HoloViews objects. HoloViews makes various models available directly in the namespace so that they can be accessed for linking:
+
+* **``cds``**: The bokeh ``ColumnDataSource`` model which holds the data used to render the plot
+* **``glyph``**: The bokeh ``Glyph`` defining the style of the element
+* **``glyph_renderer``**: The Bokeh ``GlyphRenderer`` responsible for rendering the element
+* **``plot``**: The bokeh ``Figure``
+* **``xaxis``/``yaxis``**: The Axis models of the plot
+* **``x_range``/``y_range``**: The x/y-axis ``Range1d`` models defining the axis ranges
+
+All these are made available in the JS code's namespace if we decide to provide a JS code snippet, but can also be referenced in the property mapping. We can map the widget value to a property on the ``glyph`` by providing a specification separated by periods. E.g. in this case we can map the value to the ``glyph.size``:
+
+
+```{pyodide}
+import holoviews as hv
+import holoviews.plotting.bokeh
+
+colors = ["black", "red", "blue", "green", "gray"]
+
+size_widget = pn.widgets.FloatSlider(value=8, start=3, end=20, name='Size')
+color_widget = pn.widgets.Select(name='Color', options=colors, value='black')
+
+points = hv.Points(np.random.rand(10, 2)).options(padding=0.1, line_color='black')
+
+size_widget.jslink(points, value='glyph.size')
+color_widget.jslink(points, value='glyph.fill_color')
+
+pn.Row(points, pn.Column(size_widget, color_widget))
+```
+
+Of course, if you need to transform between the displayed widget value and the value to be used on the underlying Bokeh property, you can add custom JS code as shown in [the previous section](#Linking-using-custom-JS-code). Together these linking options should allow you to express whatever interactions you wish between your Panel objects.
diff --git a/doc/how_to/links/links.md b/doc/how_to/links/links.md
new file mode 100644
index 0000000000..55d8120dc5
--- /dev/null
+++ b/doc/how_to/links/links.md
@@ -0,0 +1,48 @@
+# Linking parameters in Python
+
+To start, let's see how a ``TextInput`` widget and a ``Markdown`` pane normally behave:
+
+```{pyodide}
+import panel as pn
+
+pn.Row(
+    pn.widgets.TextInput(value="Editable text"),
+    pn.pane.Markdown('Some markdown')
+)
+```
+
+These two Panel objects are entirely independent; text can be entered into the input area and separately the Markdown pane will display its argument.
+
+What if we wanted connected input and output displays?  One option when you expect to have a live Python process available is to use the ``link`` method on Widgets to link its parameters to some other Panel object. In the simplest case we simply provide the ``target`` object and define the mapping between the source and target parameters as the keywords. In this case, we map the ``value`` parameter on the ``TextInput`` widget to the ``object`` parameter on the ``Markdown`` pane:
+
+```{pyodide}
+markdown = pn.pane.Markdown("Some text")
+text_input = pn.widgets.TextInput(value=markdown.object)
+
+text_input.link(markdown, value='object')
+
+pn.Row(text_input, markdown)
+```
+
+Now, if Python is running and you type something in the box above and press Return, the corresponding Markdown pane should update to match.  And if you use Python to directly manipulate the value of the text input (e.g. by editing the following cell to have new text in it and then executing it), then the Markdown should also update to match:
+
+```{pyodide}
+text_input.value = 'Some text'
+```
+
+For more complex mappings between the widget value and the target parameter, we can define an arbitrary transformation as a Python callback:
+
+```{pyodide}
+m = pn.pane.Markdown("")
+t = pn.widgets.TextInput()
+
+def callback(target, event):
+    target.object = event.new.upper() + '!!!'
+
+t.link(m, callbacks={'value': callback})
+t.value="Some text"
+
+pn.Row(t, m)
+```
+
+Note that here we explicitly set `t.value` before displaying the panel to trigger the linked Markdown pane to update to match the text widget; callbacks are not otherwise triggered when the links are first set up.
diff --git a/doc/how_to/links/watchers.md b/doc/how_to/links/watchers.md
new file mode 100644
index 0000000000..2b37346dfa
--- /dev/null
+++ b/doc/how_to/links/watchers.md
@@ -0,0 +1,76 @@
+# Python links using the ``watch`` method
+
+The ``link`` method used above provides a high-level API to link to parameters, which is adequate in most cases. If we need more control, we can fall back to the underlying ``param.watch`` method, which is what Panel uses internally to make all reactive features work. The main differences are that ``watch`` 1) does not assume you are linking two objects, providing more control over what you are watching, 2) allows batched callbacks when multiple parameters change at once, and 3) allows you to specify that an event should be triggered every time the parameter is set (instead of the default of only when the parameter value actually changes). If you do not need this level of control, just skip to the [Linking objects in JS](#Linking-objects-in-JS) section below.
+
+To demonstrate ``param.watch``, let us set up three different models: 1) a `Markdown` pane to display the possible options, 2) a ``Markdown`` pane to display the _selected_ options, and 3) a ``ToggleGroup`` widget that allows us to toggle between a number of options:
+
+```{pyodide}
+selections = pn.pane.Markdown(object='')
+selected = pn.pane.Markdown(object='')
+toggle = pn.widgets.ToggleGroup(options=['A', 'B'])
+```
+
+## Defining a callback
+
+Next we define a callback that can handle multiple parameter changes at once and uses the ``Event``'s ``name`` to figure out how to process the event. In this case it updates either the ``selections`` or the ``selected`` pane depending on whether ToggleGroup ``options`` or ``value`` changed:
+
+```{pyodide}
+def callback(*events):
+    print(events)
+    for event in events:
+        if event.name == 'options':
+            selections.object = 'Possible options: %s' % ', '.join(event.new)
+        elif event.name == 'value':
+            selected.object = 'Selected: %s' % ','.join(event.new)
+```
+
+## Event objects
+
+Before going any further let us discover what these ``Event`` objects are. An ``Event`` is used to signal the change in a parameter value. Event objects provide a number of useful attributes that provides additional information about the event:
+
+* **``name``**: The name of the parameter that has changed
+* **``new``**: The new value of the parameter
+* **``old``**: The old value of the parameter before the event was triggered
+* **``type``**: The type of event ('triggered', 'changed', or 'set')
+* **``what``**: Describes what about the parameter changed (usually the value but other parameter attributes can also change)
+* **``obj``**: The Parameterized instance that holds the parameter
+* **``cls``**: The Parameterized class that holds the parameter
+
+## Registering a watcher
+
+Now that we know how to define a callback and make use of ``Event`` attributes, it is time to register the callback. The ``obj.param.watch`` method lets us supply the callback along with the parameters we want to watch. Additionally we can declare whether the events should only be triggered when the parameter value changes, or every time the parameter is set:
+
+```{pyodide}
+watcher = toggle.param.watch(callback, ['options', 'value'], onlychanged=False)
+```
+
+Now let us display the widget alongside the ``Markdown`` panes that reflect the current state of the widget:
+
+```{pyodide}
+pn.Row(pn.Column(toggle, width=200, height=50), selections, pn.Spacer(width=50, height=50), selected)
+```
+
+To initialize the `selections` and `selected` we can explicitly ``trigger`` options and value events:
+
+```{pyodide}
+toggle.param.trigger('options', 'value')
+```
+
+We can also override the initial parameters using the ``set_param`` method:
+
+```{pyodide}
+options = ['A','B','C','D']
+toggle.param.set_param(options=dict(zip(options,options)), value=['D'])
+```
+
+Using `set_param` allows us to batch two separate changes (the options and the value) together, which you can see from the ``print`` output resulted into a single invocation of the callback.  You could instead have set them separately using the usual parameter-setting syntax `toggle.value=['D']; toggle.options=dict(zip(options,options))`, but batching them can be much more efficient for a non-trivial callback like a database query or a complex plot that needs updating.
+
+Now that the widgets are visible, you can toggle the option values and see the selected pane update in response via the callback (if Python is running).
+
+## Unlinking
+
+If for whatever reason we want to stop watching parameter changes we can unsubscribe by passing our ``watcher`` (returned in the ``watch`` call above) to the ``unwatch`` method:
+
+```{pyodide}
+#toggle.param.unwatch(watcher)
+```
diff --git a/doc/how_to/param/custom.md b/doc/how_to/param/custom.md
new file mode 100644
index 0000000000..ce0e5ee5ad
--- /dev/null
+++ b/doc/how_to/param/custom.md
@@ -0,0 +1,68 @@
+# Custom widgets
+
+In the previous section we saw how parameters can automatically be turned into widgets. This is possible because internally Panel maintains a mapping between parameter types and widget types. However, sometimes the default widget does not provide the most convenient UI and we want to provide an explicit hint to Panel to tell it how to render a parameter. This is possible using the ``widgets`` argument to the `Param` pane. Using the ``widgets`` keyword we can declare a mapping between the parameter name and the type of widget that is desired (as long as the widget type supports the types of values held by the parameter type).
+
+As an example, we can map a string and a number Selector to a `RadioButtonGroup` and `DiscretePlayer` respectively.
+
+```{pyodide}
+class CustomExample(param.Parameterized):
+    """An example Parameterized class"""
+
+    select_string = param.Selector(objects=["red", "yellow", "green"])
+    autocomplete_string = param.Selector(default='', objects=["red", "yellow", "green"], check_on_set=False)
+    select_number = param.Selector(objects=[0, 1, 10, 100])
+
+
+pn.Param(CustomExample.param, widgets={
+    'select_string': pn.widgets.RadioButtonGroup,
+    'autocomplete_string': pn.widgets.AutocompleteInput,
+    'select_number': pn.widgets.DiscretePlayer}
+)
+```
+
+Also, it's possible to pass arguments to the widget in order to customize it. Instead of passing the widget, pass a dictionary with the desired options. Use the ``widget_type`` keyword to map the widget.
+
+Taking up the previous example.
+
+```{pyodide}
+pn.Param(CustomExample.param, widgets={
+    'select_string': {'widget_type': pn.widgets.RadioButtonGroup, 'button_type': 'success'},
+    'autocomplete_string': {'widget_type': pn.widgets.AutocompleteInput, 'placeholder': 'Find a color...'},
+    'select_number': pn.widgets.DiscretePlayer}
+)
+```
+
+However it is also possible to explicitly construct a widget from a parameter using the `.from_param` method, which makes it easy to override widget settings using keyword arguments:
+
+
+```{pyodide}
+pn.widgets.IntSlider.from_param(Example.param.unbounded_int, start=0, end=100)
+```
+
+## Custom name
+
+By default, a param Pane has a title that is derived from the class name of its `Parameterized` object. Using the ``name`` keyword we can set any title to the pane, e.g. to improve the user interface.
+
+
+```{pyodide}
+pn.Param(CustomExample.param, name="Custom Name")
+```
+
+## Sort
+
+You can sort the widgets alphabetically by setting `sort=True`
+
+
+```{pyodide}
+pn.Param(CustomExample.param, sort=True, name="Sort by Label Example")
+```
+
+You can also specify a custom sort function that takes the (parameter name, Parameter instance) as input.
+
+
+```{pyodide}
+def sort_func(x):
+    return len(x[1].label)
+
+pn.Param(CustomExample.param, sort=sort_func, name="Sort by Label Length Example")
+```
diff --git a/doc/how_to/param/dependencies.md b/doc/how_to/param/dependencies.md
new file mode 100644
index 0000000000..bbc9f6d99e
--- /dev/null
+++ b/doc/how_to/param/dependencies.md
@@ -0,0 +1,73 @@
+# Declare parameter dependencies
+
+Declaring parameters is usually only the beginning of a workflow. In most applications these parameters are then tied to some computation. To express the relationship between a computation and the parameters it depends on, the ``param.depends`` decorator may be used on Parameterized methods. This decorator provides a hint to Panel and other Param-based libraries (e.g. HoloViews) that the method should be re-evaluated when a parameter changes.
+
+As a straightforward example without any additional dependencies we will write a small class that returns an ASCII representation of a sine wave, which depends on `phase` and `frequency` parameters. If we supply the ``.view`` method to a panel, it will automatically recompute and update the view when one or more of the parameters changes:
+
+```{pyodide}
+import panel as pn
+import numpy as np
+
+class Sine(param.Parameterized):
+
+    phase = param.Number(default=0, bounds=(0, np.pi))
+
+    frequency = param.Number(default=1, bounds=(0.1, 2))
+
+    @param.depends('phase', 'frequency')
+    def view(self):
+        y = np.sin(np.linspace(0, np.pi * 3, 40) * self.frequency + self.phase)
+        y = ((y - y.min()) / y.ptp()) * 20
+        array = np.array(
+            [list((' ' * (int(round(d)) - 1) + '*').ljust(20)) for d in y])
+        return pn.pane.Str('\n'.join([''.join(r) for r in array.T]), height=380, width=500)
+
+sine = Sine(name='ASCII Sine Wave')
+
+pn.Row(sine.param, sine.view)
+```
+
+The parameterized and annotated ``view`` method could return any one of the types handled by the [Pane objects](../user_guide/Components.md#Panes) Panel provides, making it easy to link parameters and their associated widgets to a plot or other output. Parameterized classes can therefore be a very useful pattern for encapsulating a part of a computational workflow with an associated visualization, declaratively expressing the dependencies between the parameters and the computation.
+
+By default, a Param pane will show widgets for all parameters with a `precedence` value above the value `pn.Param.display_threshold`, so you can use `precedence` to automatically hide parameters that are not meant to have widgets.  You can also explicitly choose which parameters should have widgets in a given pane, by passing a `parameters` argument.  For example, this code gives a `phase` widget, while maintaining `sine.frequency` at the initial value of `1`:
+
+
+```{pyodide}
+pn.Row(pn.panel(sine.param, parameters=['phase']), sine.view)
+```
+
+Another common pattern is linking the values of one parameter to another parameter, e.g. when dependencies between parameters exist. In the example below we will define two parameters, one for the continent and one for the country. Since we want the selection of valid countries to change when we change the continent, we define a method to do that for us. In order to link the two we express the dependency using the ``param.depends`` decorator and then ensure that we will run the method whenever the continent changes by setting ``watch=True``.
+
+We also define a ``view`` method that returns an HTML iframe displaying the country using Google Maps.
+
+
+```{pyodide}
+class GoogleMapViewer(param.Parameterized):
+
+    continent = param.ObjectSelector(default='Asia', objects=['Africa', 'Asia', 'Europe'])
+
+    country = param.ObjectSelector(default='China', objects=['China', 'Thailand', 'Japan'])
+
+    _countries = {'Africa': ['Ghana', 'Togo', 'South Africa', 'Tanzania'],
+                  'Asia'  : ['China', 'Thailand', 'Japan'],
+                  'Europe': ['Austria', 'Bulgaria', 'Greece', 'Portugal', 'Switzerland']}
+
+    @param.depends('continent', watch=True)
+    def _update_countries(self):
+        countries = self._countries[self.continent]
+        self.param['country'].objects = countries
+        self.country = countries[0]
+
+    @param.depends('country')
+    def view(self):
+        iframe = """
+        <iframe width="800" height="400" src="https://maps.google.com/maps?q={country}&z=6&output=embed"
+        frameborder="0" scrolling="no" marginheight="0" marginwidth="0"></iframe>
+        """.format(country=self.country)
+        return pn.pane.HTML(iframe, height=400)
+
+viewer = GoogleMapViewer(name='Google Map Viewer')
+pn.Row(viewer.param, viewer.view)
+```
+
+Whenever the continent changes Param will now eagerly execute the ``_update_countries`` method to change the list of countries that is displayed, which in turn triggers an update in the view method updating the map. Note that there is no need to add ``watch=True`` to decorators of methods that are passed to a Panel layout (e.g. ``viewer.View`` being passed to ``pn.Row`` here), because Panel will already handle dependencies on those methods, executing the method automatically when the dependent parameters change. Indeed, if you specify ``watch=True`` for such a method, the method will get invoked _twice_ each time a dependency changes (once by Param internally and once by Panel), so you should reserve ``watch=True`` only for methods that aren't otherwise being monitored for dependencies.
diff --git a/doc/how_to/param/index.md b/doc/how_to/param/index.md
new file mode 100644
index 0000000000..aaab07a23c
--- /dev/null
+++ b/doc/how_to/param/index.md
@@ -0,0 +1,50 @@
+# Using Param with Panel
+
+[Param](https://param.holoviz.org) is a library for handling all the user-modifiable parameters, arguments, and attributes that control your code. Panel is built on parameters, so to effectively learn to use Panel you should at least understand the basics about Param. Therefore we strongly recommend reading the first few sections of the [Param user guide](https://param.holoviz.org/user_guide/index.html).
+
+Panel supports using parameters and dependencies between parameters as expressed by ``param`` in a simple way to encapsulate dashboards as declarative, self-contained classes.
+
+::::{grid} 1 2 2 4
+:gutter: 1 1 1 2
+
+:::{grid-item-card} Building UIs using Param
+:link: uis
+:link-type: doc
+
+Discover how to generate UIs from Parameterized classes without writing any GUI related code.
+:::
+
+:::{grid-item-card} Declare Custom Widgets
+:link: custom
+:link-type: doc
+
+Discover how to extend Param based UIs with custom widgets.
+:::
+
+:::{grid-item-card} Declare Parameter dependencies
+:link: custom
+:link-type: doc
+
+Discover how to leverage `@param.depends` to express dependencies and trigger events based on UI interactions.
+:::
+
+:::{grid-item-card} Param subobjects
+:link: subobjects
+:link-type: doc
+
+Discover how to structure Parameterized classes with subobjects to create nested UIs automatically.
+:::
+
+::::
+
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+uis
+custom
+dependencies
+subobjects
+```
\ No newline at end of file
diff --git a/doc/how_to/param/subobjects.md b/doc/how_to/param/subobjects.md
new file mode 100644
index 0000000000..3a3a53bab8
--- /dev/null
+++ b/doc/how_to/param/subobjects.md
@@ -0,0 +1,99 @@
+# Parameter subobjects
+
+``Parameterized`` objects often have parameter values which are themselves ``Parameterized`` objects, forming a tree-like structure. Panel allows you to edit not just the main object's parameters but also lets you drill down to the subobject. Let us first define some classes declaring a hierarchy of Shape classes which draw a Bokeh plot of the selected shape:
+
+```{pyodide}
+from bokeh.plotting import figure
+
+class Shape(param.Parameterized):
+
+    radius = param.Number(default=1, bounds=(0, 1))
+
+    def __init__(self, **params):
+        super(Shape, self).__init__(**params)
+        self.figure = figure(x_range=(-1, 1), y_range=(-1, 1))
+        self.renderer = self.figure.line(*self._get_coords())
+
+    def _get_coords(self):
+        return [], []
+
+    def view(self):
+        return self.figure
+
+
+class Circle(Shape):
+
+    n = param.Integer(default=100, precedence=-1)
+
+    def _get_coords(self):
+        angles = np.linspace(0, 2 * np.pi, self.n + 1)
+        return (self.radius * np.sin(angles),
+                self.radius * np.cos(angles))
+
+    @param.depends('radius', watch=True)
+    def update(self):
+        xs, ys = self._get_coords()
+        self.renderer.data_source.data.update({'x': xs, 'y': ys})
+
+
+class NGon(Circle):
+
+    n = param.Integer(default=3, bounds=(3, 10), precedence=1)
+
+    @param.depends('radius', 'n', watch=True)
+    def update(self):
+        xs, ys = self._get_coords()
+        self.renderer.data_source.data.update({'x': xs, 'y': ys})
+```
+
+Now that we have multiple Shape classes we can make instances of them and declare a ``ShapeViewer`` to select between them. We can also declare two methods with parameter dependencies, updating the plot and the plot title. The important thing to note here is that the ``param.depends`` decorator can not only depend on parameters on the object itself but also on specific parameters on the subobject, e.g. ``shape.radius``, or on all parameters of the subobject, expressed as ``shape.param``.
+
+```{pyodide}
+shapes = [NGon(), Circle()]
+
+class ShapeViewer(param.Parameterized):
+
+    shape = param.ObjectSelector(default=shapes[0], objects=shapes)
+
+    @param.depends('shape')
+    def view(self):
+        return self.shape.view()
+
+    @param.depends('shape', 'shape.radius')
+    def title(self):
+        return '## %s (radius=%.1f)' % (type(self.shape).__name__, self.shape.radius)
+
+    def panel(self):
+        return pn.Column(self.title, self.view)
+```
+
+Now that we have a class with subobjects we can display it as usual.  Three main options control how the subobject is rendered:
+
+* ``expand``: Whether the subobject is expanded on initialization (``default=False``).
+* ``expand_button``: Whether there should be a button to toggle expansion; otherwise it is fixed to the initial ``expand`` value (``default=True``).
+* ``expand_layout``: A layout type or instance to expand the plot into (``default=Column``).
+
+Let us start with the default view, which provides a toggle button to expand the subobject as desired:
+
+
+```{pyodide}
+viewer = ShapeViewer()
+
+pn.Row(viewer.param, viewer.panel())
+```
+
+Alternatively we can provide a completely separate ``expand_layout`` instance to the Param pane and request that it always remains expanded using the ``expand`` and ``expand_button`` option. This allows us to lay out the main widgets and the subobject's widgets separately:
+
+
+```{pyodide}
+viewer = ShapeViewer()
+
+expand_layout = pn.Column()
+
+pn.Row(
+    pn.Column(
+        pn.panel(viewer.param, expand_button=False, expand=True, expand_layout=expand_layout),
+        "#### Subobject parameters:",
+        expand_layout),
+    viewer.panel())
+```
diff --git a/doc/how_to/param/uis.md b/doc/how_to/param/uis.md
new file mode 100644
index 0000000000..14ed5c3564
--- /dev/null
+++ b/doc/how_to/param/uis.md
@@ -0,0 +1,90 @@
+# Generating UIs using Param
+
+Parameters are Python attributes extended using the [Param library](https://param.holoviz.org) to support types, ranges, and documentation, which turns out to be just the information you need to automatically create widgets for each parameter.
+
+## Declaring and displaying parameters
+
+Internally parameters have a mapping that generates widgets appropriate for each type. This means that by declaring a `Parameterized` class we can automatically generate a full UI. Let us declare a `BaseClass`:
+
+```{pyodide}
+import param
+import panel as pn
+import pandas as pd
+import datetime as dt
+
+class BaseClass(param.Parameterized):
+    x                       = param.Parameter(default=3.14, doc="X position")
+    y                       = param.Parameter(default="Not editable", constant=True)
+    string_value            = param.String(default="str", doc="A string")
+    num_int                 = param.Integer(50000, bounds=(-200, 100000))
+    unbounded_int           = param.Integer(23)
+    float_with_hard_bounds  = param.Number(8.2, bounds=(7.5, 10))
+    float_with_soft_bounds  = param.Number(0.5, bounds=(0, None), softbounds=(0,2))
+    unbounded_float         = param.Number(30.01, precedence=0)
+    hidden_parameter        = param.Number(2.718, precedence=-1)
+    integer_range           = param.Range(default=(3, 7), bounds=(0, 10))
+    float_range             = param.Range(default=(0, 1.57), bounds=(0, 3.145))
+    dictionary              = param.Dict(default={"a": 2, "b": 9})
+```
+
+and then render the resulting UI using Panel:
+
+```{pyodide}
+pn.Param(BaseClass.param)
+```
+
+By changing a widget and re-running the following outputs, we can see that changes in the widgets are automatically reflected in Python:
+
+```{pyodide}
+BaseClass.unbounded_int
+```
+
+```{pyodide}
+BaseClass.num_int
+```
+
+The reverse is also true; editing a parameter from Python will automatically update any widgets that were generated from the parameter:
+
+```{pyodide}
+BaseClass.int_list = [1, 7]
+```
+
+Passing the ``.param`` object renders the full set of widgets, while passing a single parameter will display just one widget. In this way we can easily declare exactly which parameters to display:
+
+```{pyodide}
+pn.Row(BaseClass.param.float_range, BaseClass.param.num_int)
+```
+
+## Advanced parameters
+
+The `BaseClass` primarily declared simple parameters, however there are a wide range of parameter types covering many use cases. Below we define a subclass with some of these additional parameter types.
+
+```{pyodide}
+class Example(BaseClass):
+    """An example Parameterized class"""
+
+    timestamps = []
+
+    boolean                 = param.Boolean(True, doc="A sample Boolean parameter")
+    color                   = param.Color(default='#FFFFFF')
+    date                    = param.Date(dt.datetime(2017, 1, 1),
+                                         bounds=(dt.datetime(2017, 1, 1), dt.datetime(2017, 2, 1)))
+    dataframe               = param.DataFrame(pd._testing.makeDataFrame().iloc[:3])
+    select_string           = param.ObjectSelector(default="yellow", objects=["red", "yellow", "green"])
+    select_fn               = param.ObjectSelector(default=list,objects=[list, set, dict])
+    int_list                = param.ListSelector(default=[3, 5], objects=[1, 3, 5, 7, 9], precedence=0.5)
+    single_file             = param.FileSelector(path='../../*/*.py*', precedence=0.5)
+    multiple_files          = param.MultiFileSelector(path='../../*/*.py?', precedence=0.5)
+    record_timestamp        = param.Action(lambda x: x.timestamps.append(dt.datetime.utcnow()),
+                                           doc="""Record timestamp.""", precedence=0.7)
+
+example = Example()
+
+pn.Param(example.param)
+```
+
+`Example.timestamps` records the times you pressed the "record timestamp" button.
+
+```{pyodide}
+Example.timestamps
+```
diff --git a/doc/user_guide/APIs.md b/doc/user_guide/APIs.md
deleted file mode 100644
index ab543f7d61..0000000000
--- a/doc/user_guide/APIs.md
+++ /dev/null
@@ -1,212 +0,0 @@
-# APIs
-
-Panel can be used to make a first pass at an app or dashboard in minutes, while also allowing you to fully customize the app's behavior and appearance or flexibly integrate GUI support into long-term, large-scale software projects. To accommodate these different ways of using Panel, four different APIs are available:
-
-* **Interact functions**: Auto-generates a full UI (including widgets) given a function
-* **Reactive functions**: Linking functions or methods to widgets using ``pn.bind`` or the equivalent ``pn.depends`` decorator, declaring that the function should be re-run when those widget values change
-* **Parameterized class**: Declare parameters and their ranges in Parameterized classes, then get GUIs (and value checking!) for free
-* **Callbacks**: Generate a UI by manually declaring callbacks that update panels or panes
-
-Each of these APIs has its own benefits and drawbacks, so this section will go through each one in turn, while working through an example app and pointing out the benefits and drawback along the way. For a quick overview you can also review the API gallery examples, e.g. the [stocks_hvplot](../gallery/apis/stocks_hvplot.ipynb) app.
-
-To start with let us define some imports, load the `autompg` dataset, and define a plotting function we will be reusing throughout this user guide.
-
-
-```{pyodide}
-import hvplot.pandas
-from bokeh.sampledata.autompg import autompg
-
-def autompg_plot(x='mpg', y='hp', color='#058805'):
-    return autompg.hvplot.scatter(x, y, c=color, padding=0.1)
-
-columns = list(autompg.columns[:-2])
-```
-
-Given values for the x and y axes and a color, this function can be used to generate an interactive plot without needing any Panel components:
-
-
-```{pyodide}
-autompg_plot()
-```
-
-But if we want to let a user control the axes and the color with widgets rather than writing Python code, we can use one of the Panel APIs as shown in the rest of the notebook.
-
-
-```{pyodide}
-import panel as pn
-pn.extension()
-```
-
-## Reactive Functions
-
-The `pn.bind` reactive programming API is very similar to the ``interact`` function but is more explicit about widget selection and layout. `pn.bind` requires the programmer to select and configure widgets explicity and to lay out components explicitly, without relying on inference of widget types and ranges and without any default layouts. Specifying those aspects explicitly provides more power and control, but does typically take a bit more code and more knowledge of widget and layout components than using `interact` does. Once widgets have been bound to a reactive function, you can lay out the bound function and the widgets in any order or combination you like, including across Jupyter notebook cells if desired.
-
-### Pros:
-
-+ Very clear mapping from widgets to the arguments of the function.
-+ Very explicit layout of each of the different components.
-+ Like `interact`, doesn't typically require modifying existing visualization code.
-
-### Cons:
-
-- Typically requires a bit more code than `interact`
-
-In this model, we can use an existing plotting function just as for `interact`, but then need to declare each widget explicitly and then bind a widget to each of the arguments that we want to be interactive. The `pn.bind` function works much like [`functools.partial`](https://docs.python.org/3/library/functools.html#functools.partial) in that it binds regular arguments and keyword arguments to a function. `partial` can only bind specific, static arguments like `5`, but `pn.bind` can also bind parameters, widgets, and other dynamic functions with dependencies to the arguments, ensuring when the function is called the current values of the parameters are passed to the function. A bound function is then reactive, updating whenever the widget values change.
-
-To make the concept of binding clear, let's look at a trivial example first:
-
-
-```{pyodide}
-def fn(a,b): return f'Arguments: {a,b}'
-slider = pn.widgets.FloatSlider(value=0.5)
-
-bound_fn = pn.bind(fn, a=slider, b=2)
-bound_fn()
-```
-
-Here we can see that although `fn` required two arguments, `bound_fn` takes no arguments because `a` has been bound to the slider value and `b` to a static value.
-
-If we display the slider and bound function in Panel, we can see that everything will update reactively as you use the widget, reevaluating the function whenever the bound argument changes:
-
-
-```{pyodide}
-pn.Row(slider, bound_fn)
-```
-
-Using `pn.bind`, we can easily build something like the `interact` app above if we explicitly make widgets for each argument, bind them to the plotting function, and lay out the result with the widgets:
-
-
-```{pyodide}
-x = pn.widgets.Select(value='mpg', options=columns, name='x')
-y = pn.widgets.Select(value='hp', options=columns, name='y')
-color = pn.widgets.ColorPicker(name='Color', value='#AA0505')
-
-pn.Row(pn.Column('## MPG Explorer', x, y, color),
-       pn.bind(autompg.hvplot.scatter, x, y, c=color))
-```
-
-Notice how here we didn't even need the `autompg_plot` function here, because `bind` works with both methods and functions, so for this particular case the reactive API works out to the same amount of code as `interact`. In practice `interact` is shorter and simpler in the case of accepting the default behavior, making it simple to get started, while `pn.bind` requires a bit more code to get started but then allows easier customization and specification.
-
-If you are writing code specifically for building an app, and do not wish to keep domain and GUI code separate, the functionality of `pn.bind` is also available as a decorator `@pn.depends`:
-
-
-```{pyodide}
-x = pn.widgets.Select(value='mpg', options=columns, name='x')
-y = pn.widgets.Select(value='hp', options=columns, name='y')
-color = pn.widgets.ColorPicker(name='Color', value='#AA0505')
-
-@pn.depends(x, y, color)
-def plot(xval, yval, colorval):
-    return autompg.hvplot.scatter(xval, yval, c=colorval)
-
-pn.Row(
-    pn.Column('## MPG Explorer', x, y, color),
-    plot
-)
-```
-
-This alternative way of specifying the same app lets you declare the dependency between a function argument and a widget (or parameter) from the start, which can be clearer if you know the function will always and only be used in a GUI. Otherwise, the `pn.bind` version is preferred, because it allows you to keep the Panel-specific code separate (even in a different Python module or file) from the underlying analysis and plotting code.
-
-## Interact Functions
-
-The ``interact`` function will automatically generate a UI (including widgets) by inspecting the arguments of the function given to it, or by using additional hints you provide in the ``interact`` function call. If you have worked with the [``ipywidgets``](https://github.com/jupyter-widgets/ipywidgets) package you may already be familiar with this approach. (In fact, the Panel interact function is modeled on the one from ipywidgets, making it simpler to port code between the two platforms.) The basic idea is that given a function that returns some object, Panel will inspect the arguments to that function, try to infer appropriate widgets for those arguments, and then re-run that function to update the output whenever one of the widgets generates an event. For more detail on how interact creates widgets and other ways of using it, see the Panel [interact user guide](./Interact.md).  This section instead focuses on when and why to use this API, laying out its benefits and drawbacks.
-
-The main benefit of this approach is convenience and ease of use.  You start by writing some function that returns an object, be that a plot, a dataframe, or anything else that Panel can render. Then with a single call to `pn.interact()`, you can immediately get an interactive UI, without ever instantiating any widgets or wiring up any callbacks explicitly. Unlike ipywidgets, the ``pn.interact`` call will return a Panel. This Panel can then be further modified by laying out the widgets and output separately, or combining these components with other panes. Even though `pn.interact` itself is limited in flexibility compared to the rest of Panel, you can still unpack and reconfigure the results from it to generate fairly complex GUIs in very little code.
-
-### Pros:
-
-+ Easy to use (or at least easy to get started!).
-+ Doesn't typically require modifying existing visualization code.
-
-### Cons:
-
-- Most of the behavior is implicit, with magic happening by introspection, making it difficult to see how to modify the appearance or functionality of the resulting object.
-- Customizing the layout requires indexing into the panel returned by `interact`.
-
-The simplest `interact` call can be a one-liner, but here we'll show an example of intermediate complexity so that you get a good idea of what `interact` can do in practice. In this code, ``pn.interact`` infers the initial value for `x` and `y` from the `autompg_plot` function default arguments and their widget type and range from the `columns` list provided to `interact`. `interact` wouldn't normally put up a color widget because it would have no way of knowing that this string-type argument represents an RGB color, and so here we explicitly create a color-picker widget and pass that as the value for the color so that we can control the color as well. Finally, we unpack the result from `interact` and rearrange it in a different layout with a title, to create the final app. See the Panel [interact user guide](./Interact.md) for even simpler examples along with details about how to control the widgets and how to rearrange the layout.
-
-
-```{pyodide}
-color = pn.widgets.ColorPicker(name='Color', value='#4f4fdf')
-layout = pn.interact(autompg_plot, x=columns, y=columns, color=color)
-
-pn.Row(pn.Column('## MPG Explorer', layout[0]), layout[1])
-```
-
-## Parameterized Classes
-
-The [Param](http://param.pyviz.org) library allows expressing the parameters of a class (or a hierarchy of classes) completely independently of a GUI implementation. Panel and other libraries can then take those parameter declarations and turn them into a GUI to control the parameters. This approach allows the parameters controlling some computation to be captured specifically and explicitly (but as abstract parameters, not as widgets). Then thanks to the ``@param.depends`` decorator (similar to `@panel.depends` but for use in Parameterized classes without any dependency on Panel), it is then possible to directly express the dependencies between the parameters and the computation defined in some method on the class, all without ever importing Panel or any other GUI library. The resulting objects can then be used in both GUI and non-GUI contexts (batch computations, scripts, servers).
-
-The parameterized approach is a powerful way to encapsulate computation in self-contained classes, taking advantage of object-oriented programming patterns. It also makes it possible to express a problem completely independently from Panel or any other GUI code, while still getting a GUI for free as a last step. For more detail on using this approach see the [Param user guide](./Param.md).
-
-### Pros:
-
-+ Declarative way of expressing parameters and dependencies between parameters and computation
-+ The resulting code is not tied to any particular GUI framework and can be used in other contexts as well
-
-### Cons:
-
-- Requires writing classes
-- Less explicit about widgets to use for each parameter; can be harder to customize behavior than if widgets are instantiated explicitly
-
-In this model we declare a subclass of ``param.Parameterized``, declare the parameters we want at the class level, make an instance of the class, and finally lay out the parameters and plot method of the class.
-
-
-```{pyodide}
-import param
-
-class MPGExplorer(param.Parameterized):
-
-    x = param.Selector(objects=columns)
-    y = param.Selector(default='hp', objects=columns)
-    color = param.Color(default='#0f0f0f')
-
-    @param.depends('x', 'y', 'color') # optional in this case
-    def plot(self):
-        return autompg_plot(self.x, self.y, self.color)
-
-explorer = MPGExplorer()
-
-pn.Row(explorer.param, explorer.plot)
-```
-
-## Callbacks
-
-The callback API in panel is the lowest-level approach, affording the greatest amount of flexibility but also quickly growing in complexity because each new interactive behavior requires additional callbacks that can interact in complex ways. Nonetheless, callbacks are important to know about, and can often be used to complement the other approaches. For instance, one specific callback could be used in addition to the more reactive approaches the other APIs provide.
-
-For more details on defining callbacks see the [Links user guide](./Links.md).
-
-### Pros:
-
-+ Complete and modular control over specific events
-
-### Cons:
-
-- Complexity grows very quickly with the number of callbacks
-- Have to handle initializing the plots separately
-
-In this approach we once again define the widgets. Unlike in other approaches we then have to define the actual layout, to ensure that the callback we define has something that it can update or replace. In this case we use a single callback to update the plot, but in many cases multiple callbacks might be required.
-
-
-```{pyodide}
-x = pn.widgets.Select(value='mpg', options=columns, name='x')
-y = pn.widgets.Select(value='hp', options=columns, name='y')
-color = pn.widgets.ColorPicker(name='Color', value='#880588')
-
-layout = pn.Row(
-    pn.Column('## MPG Explorer', x, y, color),
-    autompg_plot(x.value, y.value, color.value))
-
-def update(event):
-    layout[1].object = autompg_plot(x.value, y.value, color.value)
-
-x.param.watch(update, 'value')
-y.param.watch(update, 'value')
-color.param.watch(update, 'value')
-
-layout
-```
-
-## Summary
-
-As we have seen, each of these four APIs allows building the same basic application. The choice of the appropriate API depends very much on the use case. To build a quick throwaway GUI the ``interact`` approach can be completely sufficient. A much more explicit, flexible, and maintainable version of that approach is to define a reactive function that is bound directly to a set of widgets using `pn.bind`. When writing libraries or other code that might be used independently of the actual GUI, a Parameterized class can be a great way to organize the code. Finally, if you need low-level control or want to complement any of the other approaches, defining explicit callbacks can be the best approach. Nearly all of the functionality of Panel can be accessed using any of the APIs, but each makes certain things much easier than others. Choosing the API is therefore a matter of considering the tradeoffs and of course also a matter of preference. If you still aren't sure after reading the above, then just go with the `pn.bind` reactive API!
diff --git a/doc/user_guide/Links.md b/doc/user_guide/Links.md
deleted file mode 100644
index c94c76b00c..0000000000
--- a/doc/user_guide/Links.md
+++ /dev/null
@@ -1,306 +0,0 @@
-# Linking objects in Panel
-
-In the [Param user guide](Param.md), we have seen how Parameterized classes can be used to automatically generate a graphical user interface for Python code without any additional effort. If you need full control over how your GUI is set up, you can instead manually define widgets linking directly to other objects using either Python or JavaScript (JS) callbacks. Python callbacks are simple for Python users to write and can directly access Python data structures, while JS callbacks can directly manipulate the displayed HTML document and allow setting up dynamic behavior even for exported HTML files (with no Python process running).
-
-Here we will show how to link parameters of Panel objects, typically from widgets to other objects. To do this, we will introduce three API calls:
-
-* ``obj.link``: convenient high-level API to link objects via Python calls
-* ``obj.param.watch``: powerful but lower-level Python API provided by [param](https://param.pyviz.org)
-* ``obj.jslink``: high-level API to link objects via JS code
-* ``obj.jscallback``: a lower-level API to define arbitrary Javascript callbacks
-
-At the end of this notebook, we will then show how to use these APIs to set up links between widgets and plots that work even in exported HTML files where the Python process is no longer available.
-
-
-```{pyodide}
-import numpy as np
-import panel as pn
-pn.extension()
-```
-
-## Python links using the ``link`` method
-
-To start, let's see how a ``TextInput`` widget and a ``Markdown`` pane normally behave:
-
-
-```{pyodide}
-pn.Row(pn.widgets.TextInput(value="Editable text"), pn.pane.Markdown('Some markdown'))
-```
-
-These two Panel objects are entirely independent; text can be entered into the input area and separately the Markdown pane will display its argument.
-
-What if we wanted connected input and output displays?  One option when you expect to have a live Python process available is to use the ``link`` method on Widgets to link its parameters to some other Panel object. In the simplest case we simply provide the ``target`` object and define the mapping between the source and target parameters as the keywords. In this case, we map the ``value`` parameter on the ``TextInput`` widget to the ``object`` parameter on the ``Markdown`` pane:
-
-
-```{pyodide}
-markdown = pn.pane.Markdown("Some text")
-text_input = pn.widgets.TextInput(value=markdown.object)
-
-text_input.link(markdown, value='object')
-
-pn.Row(text_input, markdown)
-```
-
-Now, if Python is running and you type something in the box above and press Return, the corresponding Markdown pane should update to match.  And if you use Python to directly manipulate the value of the text input (e.g. by editing the following cell to have new text in it and then executing it), then the Markdown should also update to match:
-
-
-```{pyodide}
-text_input.value = 'Some text'
-```
-
-For more complex mappings between the widget value and the target parameter, we can define an arbitrary transformation as a Python callback:
-
-
-```{pyodide}
-m = pn.pane.Markdown("")
-t = pn.widgets.TextInput()
-
-def callback(target, event):
-    target.object = event.new.upper() + '!!!'
-
-t.link(m, callbacks={'value': callback})
-t.value="Some text"
-
-pn.Row(t, m)
-```
-
-Note that here we explicitly set `t.value` before displaying the panel to trigger the linked Markdown pane to update to match the text widget; callbacks are not otherwise triggered when the links are first set up.
-
-
-## Python links using the ``watch`` method
-
-The ``link`` method used above provides a high-level API to link to parameters, which is adequate in most cases. If we need more control, we can fall back to the underlying ``param.watch`` method, which is what Panel uses internally to make all reactive features work. The main differences are that ``watch`` 1) does not assume you are linking two objects, providing more control over what you are watching, 2) allows batched callbacks when multiple parameters change at once, and 3) allows you to specify that an event should be triggered every time the parameter is set (instead of the default of only when the parameter value actually changes). If you do not need this level of control, just skip to the [Linking objects in JS](#Linking-objects-in-JS) section below.
-
-To demonstrate ``param.watch``, let us set up three different models: 1) a `Markdown` pane to display the possible options, 2) a ``Markdown`` pane to display the _selected_ options, and 3) a ``ToggleGroup`` widget that allows us to toggle between a number of options:
-
-```{pyodide}
-selections = pn.pane.Markdown(object='')
-selected = pn.pane.Markdown(object='')
-toggle = pn.widgets.ToggleGroup(options=['A', 'B'])
-```
-
-### Defining a callback
-
-Next we define a callback that can handle multiple parameter changes at once and uses the ``Event``'s ``name`` to figure out how to process the event. In this case it updates either the ``selections`` or the ``selected`` pane depending on whether ToggleGroup ``options`` or ``value`` changed:
-
-
-```{pyodide}
-def callback(*events):
-    print(events)
-    for event in events:
-        if event.name == 'options':
-            selections.object = 'Possible options: %s' % ', '.join(event.new)
-        elif event.name == 'value':
-            selected.object = 'Selected: %s' % ','.join(event.new)
-```
-
-### Event objects
-
-Before going any further let us discover what these ``Event`` objects are. An ``Event`` is used to signal the change in a parameter value. Event objects provide a number of useful attributes that provides additional information about the event:
-
-* **``name``**: The name of the parameter that has changed
-* **``new``**: The new value of the parameter
-* **``old``**: The old value of the parameter before the event was triggered
-* **``type``**: The type of event ('triggered', 'changed', or 'set')
-* **``what``**: Describes what about the parameter changed (usually the value but other parameter attributes can also change)
-* **``obj``**: The Parameterized instance that holds the parameter
-* **``cls``**: The Parameterized class that holds the parameter
-
-### Registering a watcher
-
-Now that we know how to define a callback and make use of ``Event`` attributes, it is time to register the callback. The ``obj.param.watch`` method lets us supply the callback along with the parameters we want to watch. Additionally we can declare whether the events should only be triggered when the parameter value changes, or every time the parameter is set:
-
-
-```{pyodide}
-watcher = toggle.param.watch(callback, ['options', 'value'], onlychanged=False)
-```
-
-Now let us display the widget alongside the ``Markdown`` panes that reflect the current state of the widget:
-
-
-```{pyodide}
-pn.Row(pn.Column(toggle, width=200, height=50), selections, pn.Spacer(width=50, height=50), selected)
-```
-
-To initialize the `selections` and `selected` we can explicitly ``trigger`` options and value events:
-
-
-```{pyodide}
-toggle.param.trigger('options', 'value')
-```
-
-We can also override the initial parameters using the ``set_param`` method:
-
-
-```{pyodide}
-options = ['A','B','C','D']
-toggle.param.set_param(options=dict(zip(options,options)), value=['D'])
-```
-
-Using `set_param` allows us to batch two separate changes (the options and the value) together, which you can see from the ``print`` output resulted into a single invocation of the callback.  You could instead have set them separately using the usual parameter-setting syntax `toggle.value=['D']; toggle.options=dict(zip(options,options))`, but batching them can be much more efficient for a non-trivial callback like a database query or a complex plot that needs updating.
-
-Now that the widgets are visible, you can toggle the option values and see the selected pane update in response via the callback (if Python is running).
-
-### Unlinking
-
-If for whatever reason we want to stop watching parameter changes we can unsubscribe by passing our ``watcher`` (returned in the ``watch`` call above) to the ``unwatch`` method:
-
-
-```{pyodide}
-#toggle.param.unwatch(watcher)
-```
-
-## Linking objects in JS
-
-Linking objects in Python is often very convenient, because it allows writing code entirely in Python. However, it also requires a live Python kernel. If instead we want a static example (e.g. on a simple website or in an email) to have custom interactivity, or we simply want to avoid the overhead of having to call back into Python, we can define links in JavaScript.
-
-### Linking Panel components
-
-To begin with let us see how we can express simple links between standard Panel components before digging into some more specific and complex examples.
-
-#### Linking model properties
-
-Let us start by rehashing the example from above, linking the ``value`` of the ``TextInput`` widget to the ``object`` property of the ``Markdown`` pane:
-
-
-```{pyodide}
-markdown = pn.pane.Markdown('Markdown display')
-text_input = pn.widgets.TextInput(value=markdown.object)
-
-link = text_input.jslink(markdown, value='object')
-
-pn.Row(text_input, markdown)
-```
-
-As you can see the signature is identical to the ``link`` example above, but here Panel translates the specification into a JS code snippet which syncs the properties on the underlying Bokeh properties. But now if you edit the widget and press Return, the Markdown display will automatically update even in a static HTML web page.
-
-#### Linking bi-directionally
-
-When you want the source and target to be linked bi-directionally, i.e. a change in one will automatically trigger a change in the other you can simply set the `bidirectional` argument:
-
-
-```{pyodide}
-t1 = pn.widgets.TextInput()
-t2 = pn.widgets.TextInput()
-
-t1.jslink(t2, value='value', bidirectional=True)
-
-pn.Row(t1, t2)
-```
-
-#### Linking using custom JS code
-
-Since everything happens in JS for a `jslink`, we can't provide a Python callback. Instead, we can define a JS code snippet, which is executed when a property changes. E.g. we can define a little code snippet which adds HTML bold tags (``<b>``) around the text before setting it on the target. The code argument should map from the parameter/property on the source object to the JS code snippet to execute:
-
-
-```{pyodide}
-markdown = pn.pane.Markdown("<b>Markdown display</b>", width=400)
-text_input = pn.widgets.TextInput(value="Markdown display")
-
-code = '''
-    target.text = '<b>' + source.value + '</b>'
-'''
-link = text_input.jslink(markdown, code={'value': code})
-
-pn.Row(text_input, markdown)
-```
-
-Here ``source`` and ``target`` are made available in the JavaScript namespace, allowing us to arbitrarily modify the models in response to property change events. Note however that the underlying Bokeh model property names may differ slightly from the naming of the parameters on Panel objects, e.g. the 'object' parameter on the Markdown pane translates to the 'text' property on the Bokeh model used to render the ``Markdown``.
-
-Of course, you can still update the value from Python, and it will automatically update the linked markdown:
-
-
-```{pyodide}
-text_input.value="Markdown display"
-```
-
-#### Open URL
-
-As an example of using `jslink`, here we open a URL from the ``TextInput`` widget value. A new browser tab will open with the provided URL:
-
-
-```{pyodide}
-button = pn.widgets.Button(name='Open URL', button_type = 'primary')
-url = pn.widgets.TextInput(name='URL', value = 'https://pyviz.org/')
-button.js_on_click(args={'target': url}, code='window.open(target.value)')
-pn.Row(url, button)
-```
-
-## Defining Javascript callbacks
-
-Sometimes defining a simple link between to objects is not sufficient, e.g. when there are a number of objects involved. In these cases it is helpful to be able to define arbitrary Javascript callbacks. A very simple example is a very basic calculator which allows multiplying or adding two values, in this case we have two widgets to input numbers, a selector to pick the operation, a display for the result and a button.
-
-To implement this we define a `jscallback`, which is triggered when the `Button.clicks` property changes and provide a number of `args` allowing us to access the values of the various widgets:
-
-
-```{pyodide}
-value1 =   pn.widgets.Spinner(value=0, width=75)
-operator = pn.widgets.Select(value='*', options=['*', '+'], width=50, align='center')
-value2 =   pn.widgets.Spinner(value=0, width=75)
-button =   pn.widgets.Button(name='=', width=50)
-result =   pn.widgets.StaticText(value='0', width=50, align='center')
-
-button.jscallback(clicks="""
-if (op.value == '*')
-  result.text = (v1.value * v2.value).toString()
-else
-  result.text = (v1.value + v2.value).toString()
-""", args={'op': operator, 'result': result, 'v1': value1, 'v2': value2})
-
-pn.Row(value1, operator, value2, button, result)
-```
-
-## Linking Plots
-
-The above examples link widgets to simple static panes, but links are probably most useful when combined with dynamic objects like plots.
-
-### Bokeh
-
-The ``jslink`` API trivially allows us to link a parameter on a Panel widget to a Bokeh plot property. Here we create a Bokeh Figure with a simple sine curve. The ``jslink`` method allows us to pass any Bokeh model held by the Figure as the ``target``, then link the widget value to some property on it. E.g. here we link a ``FloatSlider`` value to the ``line_width`` of the ``Line`` glyph:
-
-
-```{pyodide}
-from bokeh.plotting import figure
-
-p = figure(width=300, height=300)
-xs = np.linspace(0, 10)
-r = p.line(xs, np.sin(xs))
-
-width_slider = pn.widgets.FloatSlider(name='Line Width', start=0.1, end=10)
-width_slider.jslink(r.glyph, value='line_width')
-
-pn.Column(width_slider, p)
-```
-
-### HoloViews
-
-Bokeh models allow us to directly access the underlying models and properties, but this access is more indirect when working with HoloViews objects. HoloViews makes various models available directly in the namespace so that they can be accessed for linking:
-
-* **``cds``**: The bokeh ``ColumnDataSource`` model which holds the data used to render the plot
-* **``glyph``**: The bokeh ``Glyph`` defining the style of the element
-* **``glyph_renderer``**: The Bokeh ``GlyphRenderer`` responsible for rendering the element
-* **``plot``**: The bokeh ``Figure``
-* **``xaxis``/``yaxis``**: The Axis models of the plot
-* **``x_range``/``y_range``**: The x/y-axis ``Range1d`` models defining the axis ranges
-
-All these are made available in the JS code's namespace if we decide to provide a JS code snippet, but can also be referenced in the property mapping. We can map the widget value to a property on the ``glyph`` by providing a specification separated by periods. E.g. in this case we can map the value to the ``glyph.size``:
-
-
-```{pyodide}
-import holoviews as hv
-import holoviews.plotting.bokeh
-
-colors = ["black", "red", "blue", "green", "gray"]
-
-size_widget = pn.widgets.FloatSlider(value=8, start=3, end=20, name='Size')
-color_widget = pn.widgets.Select(name='Color', options=colors, value='black')
-
-points = hv.Points(np.random.rand(10, 2)).options(padding=0.1, line_color='black')
-
-size_widget.jslink(points, value='glyph.size')
-color_widget.jslink(points, value='glyph.fill_color')
-
-pn.Row(points, pn.Column(size_widget, color_widget))
-```
-
-Of course, if you need to transform between the displayed widget value and the value to be used on the underlying Bokeh property, you can add custom JS code as shown in [the previous section](#Linking-using-custom-JS-code). Together these linking options should allow you to express whatever interactions you wish between your Panel objects.
diff --git a/doc/user_guide/Param.md b/doc/user_guide/Param.md
deleted file mode 100644
index b42cb2d1e7..0000000000
--- a/doc/user_guide/Param.md
+++ /dev/null
@@ -1,359 +0,0 @@
-# Using Param with Panel
-
-Panel supports using parameters and dependencies between parameters as expressed by ``param`` in a simple way to encapsulate dashboards as declarative, self-contained classes.
-
-Parameters are Python attributes extended using the [Param library](https://github.com/holoviz/param) to support types, ranges, and documentation, which turns out to be just the information you need to automatically create widgets for each parameter.
-
-Additionally Panel provides support for linking parameters to the URL query string to allow parameterizing an app very easily.
-
-## Parameters and widgets
-
-To use this approach, first declare some Parameterized classes with various Parameters:
-
-
-```{pyodide}
-import param
-import pandas as pd
-import datetime as dt
-
-class BaseClass(param.Parameterized):
-    x                       = param.Parameter(default=3.14, doc="X position")
-    y                       = param.Parameter(default="Not editable", constant=True)
-    string_value            = param.String(default="str", doc="A string")
-    num_int                 = param.Integer(50000, bounds=(-200, 100000))
-    unbounded_int           = param.Integer(23)
-    float_with_hard_bounds  = param.Number(8.2, bounds=(7.5, 10))
-    float_with_soft_bounds  = param.Number(0.5, bounds=(0, None), softbounds=(0,2))
-    unbounded_float         = param.Number(30.01, precedence=0)
-    hidden_parameter        = param.Number(2.718, precedence=-1)
-    integer_range           = param.Range(default=(3, 7), bounds=(0, 10))
-    float_range             = param.Range(default=(0, 1.57), bounds=(0, 3.145))
-    dictionary              = param.Dict(default={"a": 2, "b": 9})
-
-
-class Example(BaseClass):
-    """An example Parameterized class"""
-    timestamps = []
-
-    boolean                 = param.Boolean(True, doc="A sample Boolean parameter")
-    color                   = param.Color(default='#FFFFFF')
-    date                    = param.Date(dt.datetime(2017, 1, 1),
-                                         bounds=(dt.datetime(2017, 1, 1), dt.datetime(2017, 2, 1)))
-    dataframe               = param.DataFrame(pd._testing.makeDataFrame().iloc[:3])
-    select_string           = param.ObjectSelector(default="yellow", objects=["red", "yellow", "green"])
-    select_fn               = param.ObjectSelector(default=list,objects=[list, set, dict])
-    int_list                = param.ListSelector(default=[3, 5], objects=[1, 3, 5, 7, 9], precedence=0.5)
-    single_file             = param.FileSelector(path='../../*/*.py*', precedence=0.5)
-    multiple_files          = param.MultiFileSelector(path='../../*/*.py?', precedence=0.5)
-    record_timestamp        = param.Action(lambda x: x.timestamps.append(dt.datetime.utcnow()),
-                                           doc="""Record timestamp.""", precedence=0.7)
-
-Example.num_int
-```
-
-As you can see, declaring Parameters depends only on the separate Param library.  Parameters are a simple idea with some properties that are crucial for helping you create clean, usable code:
-
-- The Param library is pure Python with no dependencies, which makes it easy to include in any code without tying it to a particular GUI or widgets library, or even to the Jupyter notebook.
-- Parameter declarations focus on semantic information relevant to your domain, allowing you to avoid polluting your domain-specific code with anything that ties it to a particular way of displaying or interacting with it.
-- Parameters can be defined wherever they make sense in your inheritance hierarchy, allowing you to document, type, and range-limit them _once_, with all of those properties inherited by any base class.  E.g. parameters work the same here whether they were declared in `BaseClass` or `Example`, which makes it easy to provide this metadata once, and avoiding duplicating it throughout the code wherever ranges or types need checking or documentation needs to be stored.
-
-If you then decide to use these Parameterized classes in a notebook or web-server environment, you can `import panel` and easily display and edit the parameter values as an optional additional step:
-
-
-```{pyodide}
-import panel as pn
-
-pn.extension()
-
-base = BaseClass()
-pn.Row(Example.param, base.param)
-```
-
-As you can see, Panel does not need to be provided with any knowledge of your domain-specific application, not even the names of your parameters; it simply displays widgets for whatever Parameters may have been defined on that object.  Using Param with Panel thus achieves a nearly complete separation between your domain-specific code and your display code, making it vastly easier to maintain both of them over time.  Here even the `msg` button behavior was specified declaratively, as an action that can be invoked (printing "Hello") independently of whether it is used in a GUI or other context.
-
-Interacting with the widgets above is only supported in the notebook and on Bokeh server, but you can also export static renderings of the widgets to a file or web page.
-
-By default, editing values in this way requires you to run the notebook cell by cell -- when you get to the above cell, edit the values as you like, and then move on to execute subsequent cells, where any reference to those parameter values will use your interactively selected setting:
-
-
-```{pyodide}
-Example.unbounded_int
-```
-
-
-```{pyodide}
-Example.num_int
-```
-
-The reverse is possible; editing a parameter from Python will automatically update any widgets that were generated from the parameter:
-
-
-```{pyodide}
-Example.int_list = [1, 7]
-```
-
-Example.timestamps records the times you pressed the "record timestamp" button.
-
-
-```{pyodide}
-Example.timestamps
-```
-
-Passing the ``.param`` object renders the full set of widgets, while passing a single parameter will display just one widget. In this way we can easily declare exactly which parameters to display:
-
-
-```{pyodide}
-pn.Row(Example.param.float_range, Example.param.num_int)
-```
-
-As you can see, you can access the parameter values at the class level from within the notebook to control behavior explicitly, e.g. to select what to show in subsequent cells.  Moreover, any instances of the Parameterized classes in your own code will now use the new parameter values unless specifically overridden in that instance, so you can now import and use your domain-specific library however you like, knowing that it will use your interactive selections wherever those classes appear.  None of the domain-specific code needs to know or care that you used Panel; it will simply see new values for whatever attributes were changed interactively.  Panel thus allows you to provide notebook-specific, domain-specific interactive functionality without ever tying your domain-specific code to the notebook environment. This default behavior can also be modified if you wish, as outlined below.
-
-### Custom widgets
-
-In the previous section we saw how parameters can automatically be turned into widgets. This is possible because internally Panel maintains a mapping between parameter types and widget types. However, sometimes the default widget does not provide the most convenient UI and we want to provide an explicit hint to Panel to tell it how to render a parameter. This is possible using the ``widgets`` argument to the `Param` pane. Using the ``widgets`` keyword we can declare a mapping between the parameter name and the type of widget that is desired (as long as the widget type supports the types of values held by the parameter type).
-
-As an example, we can map a string and a number Selector to a RadioButtonGroup and DiscretePlayer respectively.
-
-
-```{pyodide}
-class CustomExample(param.Parameterized):
-    """An example Parameterized class"""
-
-    select_string = param.Selector(objects=["red", "yellow", "green"])
-    autocomplete_string = param.Selector(default='', objects=["red", "yellow", "green"], check_on_set=False)
-    select_number = param.Selector(objects=[0, 1, 10, 100])
-
-
-pn.Param(CustomExample.param, widgets={
-    'select_string': pn.widgets.RadioButtonGroup,
-    'autocomplete_string': pn.widgets.AutocompleteInput,
-    'select_number': pn.widgets.DiscretePlayer}
-)
-```
-
-Also, it's possible to pass arguments to the widget in order to customize it. Instead of passing the widget, pass a dictionary with the desired options. Use the ``widget_type`` keyword to map the widget.
-
-Taking up the previous example.
-
-
-```{pyodide}
-pn.Param(CustomExample.param, widgets={
-    'select_string': {'widget_type': pn.widgets.RadioButtonGroup, 'button_type': 'success'},
-    'autocomplete_string': {'widget_type': pn.widgets.AutocompleteInput, 'placeholder': 'Find a color...'},
-    'select_number': pn.widgets.DiscretePlayer}
-)
-```
-
-However it is also possible to explicitly construct a widget from a parameter using the `.from_param` method, which makes it easy to override widget settings using keyword arguments:
-
-
-```{pyodide}
-pn.widgets.IntSlider.from_param(Example.param.unbounded_int, start=0, end=100)
-```
-
-### Custom name
-
-By default, a param Pane has a title that is derived from the class name of its `Parameterized` object. Using the ``name`` keyword we can set any title to the pane, e.g. to improve the user interface.
-
-
-```{pyodide}
-pn.Param(CustomExample.param, name="Custom Name")
-```
-
-### Sort
-
-You can sort the widgets alphabetically by setting `sort=True`
-
-
-```{pyodide}
-pn.Param(CustomExample.param, sort=True, name="Sort by Label Example")
-```
-
-You can also specify a custom sort function that takes the (parameter name, Parameter instance) as input.
-
-
-```{pyodide}
-def sort_func(x):
-    return len(x[1].label)
-pn.Param(CustomExample.param, sort=sort_func, name="Sort by Label Length Example")
-```
-
-## Parameter dependencies
-
-Declaring parameters is usually only the beginning of a workflow. In most applications these parameters are then tied to some computation. To express the relationship between a computation and the parameters it depends on, the ``param.depends`` decorator may be used on Parameterized methods. This decorator provides a hint to Panel and other Param-based libraries (e.g. HoloViews) that the method should be re-evaluated when a parameter changes.
-
-As a straightforward example without any additional dependencies we will write a small class that returns an ASCII representation of a sine wave, which depends on `phase` and `frequency` parameters. If we supply the ``.view`` method to a panel, it will automatically recompute and update the view when one or more of the parameters changes:
-
-
-```{pyodide}
-import numpy as np
-
-
-class Sine(param.Parameterized):
-
-    phase = param.Number(default=0, bounds=(0, np.pi))
-
-    frequency = param.Number(default=1, bounds=(0.1, 2))
-
-    @param.depends('phase', 'frequency')
-    def view(self):
-        y = np.sin(np.linspace(0, np.pi * 3, 40) * self.frequency + self.phase)
-        y = ((y - y.min()) / y.ptp()) * 20
-        array = np.array(
-            [list((' ' * (int(round(d)) - 1) + '*').ljust(20)) for d in y])
-        return pn.pane.Str('\n'.join([''.join(r) for r in array.T]), height=380, width=500)
-
-
-sine = Sine(name='ASCII Sine Wave')
-pn.Row(sine.param, sine.view)
-```
-
-The parameterized and annotated ``view`` method could return any one of the types handled by the [Pane objects](./Components.md#Panes) Panel provides, making it easy to link parameters and their associated widgets to a plot or other output. Parameterized classes can therefore be a very useful pattern for encapsulating a part of a computational workflow with an associated visualization, declaratively expressing the dependencies between the parameters and the computation.
-
-By default, a Param pane will show widgets for all parameters with a `precedence` value above the value `pn.Param.display_threshold`, so you can use `precedence` to automatically hide parameters that are not meant to have widgets.  You can also explicitly choose which parameters should have widgets in a given pane, by passing a `parameters` argument.  For example, this code gives a `phase` widget, while maintaining `sine.frequency` at the initial value of `1`:
-
-
-```{pyodide}
-pn.Row(pn.panel(sine.param, parameters=['phase']), sine.view)
-```
-
-Another common pattern is linking the values of one parameter to another parameter, e.g. when dependencies between parameters exist. In the example below we will define two parameters, one for the continent and one for the country. Since we want the selection of valid countries to change when we change the continent, we define a method to do that for us. In order to link the two we express the dependency using the ``param.depends`` decorator and then ensure that we will run the method whenever the continent changes by setting ``watch=True``.
-
-We also define a ``view`` method that returns an HTML iframe displaying the country using Google Maps.
-
-
-```{pyodide}
-class GoogleMapViewer(param.Parameterized):
-
-    continent = param.ObjectSelector(default='Asia', objects=['Africa', 'Asia', 'Europe'])
-
-    country = param.ObjectSelector(default='China', objects=['China', 'Thailand', 'Japan'])
-
-    _countries = {'Africa': ['Ghana', 'Togo', 'South Africa', 'Tanzania'],
-                  'Asia'  : ['China', 'Thailand', 'Japan'],
-                  'Europe': ['Austria', 'Bulgaria', 'Greece', 'Portugal', 'Switzerland']}
-
-    @param.depends('continent', watch=True)
-    def _update_countries(self):
-        countries = self._countries[self.continent]
-        self.param['country'].objects = countries
-        self.country = countries[0]
-
-    @param.depends('country')
-    def view(self):
-        iframe = """
-        <iframe width="800" height="400" src="https://maps.google.com/maps?q={country}&z=6&output=embed"
-        frameborder="0" scrolling="no" marginheight="0" marginwidth="0"></iframe>
-        """.format(country=self.country)
-        return pn.pane.HTML(iframe, height=400)
-
-viewer = GoogleMapViewer(name='Google Map Viewer')
-pn.Row(viewer.param, viewer.view)
-```
-
-Whenever the continent changes Param will now eagerly execute the ``_update_countries`` method to change the list of countries that is displayed, which in turn triggers an update in the view method updating the map. Note that there is no need to add ``watch=True`` to decorators of methods that are passed to a Panel layout (e.g. ``viewer.View`` being passed to ``pn.Row`` here), because Panel will already handle dependencies on those methods, executing the method automatically when the dependent parameters change. Indeed, if you specify ``watch=True`` for such a method, the method will get invoked _twice_ each time a dependency changes (once by Param internally and once by Panel), so you should reserve ``watch=True`` only for methods that aren't otherwise being monitored for dependencies.
-
-### Parameter subobjects
-
-``Parameterized`` objects often have parameter values which are themselves ``Parameterized`` objects, forming a tree-like structure. Panel allows you to edit not just the main object's parameters but also lets you drill down to the subobject. Let us first define some classes declaring a hierarchy of Shape classes which draw a Bokeh plot of the selected shape:
-
-
-```{pyodide}
-from bokeh.plotting import figure
-
-
-class Shape(param.Parameterized):
-
-    radius = param.Number(default=1, bounds=(0, 1))
-
-    def __init__(self, **params):
-        super(Shape, self).__init__(**params)
-        self.figure = figure(x_range=(-1, 1), y_range=(-1, 1))
-        self.renderer = self.figure.line(*self._get_coords())
-
-    def _get_coords(self):
-        return [], []
-
-    def view(self):
-        return self.figure
-
-
-class Circle(Shape):
-
-    n = param.Integer(default=100, precedence=-1)
-
-    def _get_coords(self):
-        angles = np.linspace(0, 2 * np.pi, self.n + 1)
-        return (self.radius * np.sin(angles),
-                self.radius * np.cos(angles))
-
-    @param.depends('radius', watch=True)
-    def update(self):
-        xs, ys = self._get_coords()
-        self.renderer.data_source.data.update({'x': xs, 'y': ys})
-
-
-class NGon(Circle):
-
-    n = param.Integer(default=3, bounds=(3, 10), precedence=1)
-
-    @param.depends('radius', 'n', watch=True)
-    def update(self):
-        xs, ys = self._get_coords()
-        self.renderer.data_source.data.update({'x': xs, 'y': ys})
-```
-
-Now that we have multiple Shape classes we can make instances of them and declare a ``ShapeViewer`` to select between them. We can also declare two methods with parameter dependencies, updating the plot and the plot title. The important thing to note here is that the ``param.depends`` decorator can not only depend on parameters on the object itself but also on specific parameters on the subobject, e.g. ``shape.radius``, or on all parameters of the subobject, expressed as ``shape.param``.
-
-
-```{pyodide}
-shapes = [NGon(), Circle()]
-
-class ShapeViewer(param.Parameterized):
-
-    shape = param.ObjectSelector(default=shapes[0], objects=shapes)
-
-    @param.depends('shape')
-    def view(self):
-        return self.shape.view()
-
-    @param.depends('shape', 'shape.radius')
-    def title(self):
-        return '## %s (radius=%.1f)' % (type(self.shape).__name__, self.shape.radius)
-
-    def panel(self):
-        return pn.Column(self.title, self.view)
-```
-
-Now that we have a class with subobjects we can display it as usual.  Three main options control how the subobject is rendered:
-
-* ``expand``: Whether the subobject is expanded on initialization (``default=False``).
-* ``expand_button``: Whether there should be a button to toggle expansion; otherwise it is fixed to the initial ``expand`` value (``default=True``).
-* ``expand_layout``: A layout type or instance to expand the plot into (``default=Column``).
-
-Let us start with the default view, which provides a toggle button to expand the subobject as desired:
-
-
-```{pyodide}
-viewer = ShapeViewer()
-
-pn.Row(viewer.param, viewer.panel())
-```
-
-Alternatively we can provide a completely separate ``expand_layout`` instance to the Param pane and request that it always remains expanded using the ``expand`` and ``expand_button`` option. This allows us to lay out the main widgets and the subobject's widgets separately:
-
-
-```{pyodide}
-viewer = ShapeViewer()
-
-expand_layout = pn.Column()
-
-pn.Row(
-    pn.Column(
-        pn.panel(viewer.param, expand_button=False, expand=True, expand_layout=expand_layout),
-        "#### Subobject parameters:",
-        expand_layout),
-    viewer.panel())
-```
-
-In this user guide we have seen how to leverage Param to declare parameters, which Panel can then turn into a GUI with little additionl effort or code. We have also seen how to link parameters to views and to other parameters using the ``param.depends`` operator. This approach allows building complex and reactive panels. In the [pipelines user guide](Pipelines.md) we can discover how to link multiple such classes into pipelines, making it possible to encapsulate complex workflows in clean self-contained classes.
diff --git a/doc/user_guide/index.rst b/doc/user_guide/index.rst
index 949a94745a..e55ee9886d 100644
--- a/doc/user_guide/index.rst
+++ b/doc/user_guide/index.rst
@@ -19,9 +19,6 @@ the core guide sections.
 `Components <Components.html>`_
  An introduction to the three main component types: Widgets, Panes, and Panels.
 
-`APIs <APIs.html>`_
- An introduction to the different APIs panel provides to build interactive applications and dashboards.
-
 Reference guide
 ---------------
 
@@ -38,12 +35,6 @@ when needed.
 `Widgets <Widgets.html>`_
  Declaring and working with Panel widgets.
 
-`Parameters <Param.html>`_
- Using Param to express panels in a self-contained class.
-
-`Linking <Links.html>`_
- Defining links between Panel objects in Python and Javascript.
-
 `Templates <Templates.html>`_
  Learn how to compose multiple Panels into a custom HTML document.
 

From eb385a95098e3791b32233d74507270288709bb5 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 4 Jan 2023 13:32:32 +0000
Subject: [PATCH 07/15] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 doc/how_to/apis/callbacks.md     | 2 +-
 doc/how_to/apis/interact.md      | 2 +-
 doc/how_to/apis/parameterized.md | 2 +-
 doc/how_to/index.md              | 2 +-
 doc/how_to/links/index.md        | 6 +++---
 doc/how_to/param/index.md        | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/doc/how_to/apis/callbacks.md b/doc/how_to/apis/callbacks.md
index 2cdb16f72e..e5710ecb21 100644
--- a/doc/how_to/apis/callbacks.md
+++ b/doc/how_to/apis/callbacks.md
@@ -40,4 +40,4 @@ y.param.watch(update, 'value')
 color.param.watch(update, 'value')
 
 layout
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/apis/interact.md b/doc/how_to/apis/interact.md
index 85c85779fb..ff02395528 100644
--- a/doc/how_to/apis/interact.md
+++ b/doc/how_to/apis/interact.md
@@ -52,4 +52,4 @@ color = pn.widgets.ColorPicker(name='Color', value='#4f4fdf')
 layout = pn.interact(autompg_plot, x=columns, y=columns, color=color)
 
 pn.Row(pn.Column('## MPG Explorer', layout[0]), layout[1])
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/apis/parameterized.md b/doc/how_to/apis/parameterized.md
index 1e2ef56293..c91b351aaf 100644
--- a/doc/how_to/apis/parameterized.md
+++ b/doc/how_to/apis/parameterized.md
@@ -42,4 +42,4 @@ class MPGExplorer(param.Parameterized):
 explorer = MPGExplorer()
 
 pn.Row(explorer.param, explorer.plot)
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index 41506ca33c..942b6502bd 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -89,7 +89,7 @@ How to run Panel applications entirely in the browser using WebAssembly, Pyodide
 ::::
 
 
-## Server configuration and deployment 
+## Server configuration and deployment
 
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
diff --git a/doc/how_to/links/index.md b/doc/how_to/links/index.md
index 78af46656f..016dec6a5f 100644
--- a/doc/how_to/links/index.md
+++ b/doc/how_to/links/index.md
@@ -4,8 +4,8 @@ In the [Param how-to guide](../param/index), we have seen how Parameterized clas
 
 Here we will show how to link parameters of Panel objects, typically from widgets to other objects. To do this, we will introduce three API calls:
 
-* ``obj.link``: 
-* ``obj.param.watch``: 
+* ``obj.link``:
+* ``obj.param.watch``:
 * ``obj.jslink``: high-level API to link objects via JS code
 * ``obj.jscallback``: a lower-level API to define arbitrary Javascript callbacks
 
@@ -60,4 +60,4 @@ links
 jslinks
 link_plots
 jscallback
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/param/index.md b/doc/how_to/param/index.md
index aaab07a23c..e265bbd4e0 100644
--- a/doc/how_to/param/index.md
+++ b/doc/how_to/param/index.md
@@ -47,4 +47,4 @@ uis
 custom
 dependencies
 subobjects
-```
\ No newline at end of file
+```

From e25f3de579cbbf366642f40f22f858a0f857c560 Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Wed, 4 Jan 2023 14:39:19 +0100
Subject: [PATCH 08/15] Small fixes

---
 doc/how_to/index.md          |  1 +
 doc/how_to/links/index.md    | 11 ++---------
 doc/how_to/links/watchers.md |  2 ++
 doc/how_to/param/custom.md   |  3 +++
 doc/how_to/wasm/index.md     |  2 +-
 5 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index 942b6502bd..7dd37fbcbe 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -131,6 +131,7 @@ How to configure OAuth to add authentication to a server deployment.
 :maxdepth: 2
 
 apis/index
+param/index
 links/index
 callbacks/index
 state/index
diff --git a/doc/how_to/links/index.md b/doc/how_to/links/index.md
index 016dec6a5f..d8f6e5e1a3 100644
--- a/doc/how_to/links/index.md
+++ b/doc/how_to/links/index.md
@@ -2,14 +2,7 @@
 
 In the [Param how-to guide](../param/index), we have seen how Parameterized classes can be used to automatically generate a graphical user interface for Python code without any additional effort. If you need full control over how your GUI is set up, you can instead manually define widgets linking directly to other objects using either Python or JavaScript (JS) callbacks. Python callbacks are simple for Python users to write and can directly access Python data structures, while JS callbacks can directly manipulate the displayed HTML document and allow setting up dynamic behavior even for exported HTML files (with no Python process running).
 
-Here we will show how to link parameters of Panel objects, typically from widgets to other objects. To do this, we will introduce three API calls:
-
-* ``obj.link``:
-* ``obj.param.watch``:
-* ``obj.jslink``: high-level API to link objects via JS code
-* ``obj.jscallback``: a lower-level API to define arbitrary Javascript callbacks
-
-::::{grid} 1 2 2 4
+::::{grid} 1 3 3 3
 :gutter: 1 1 1 2
 
 :::{grid-item-card} Watchers
@@ -59,5 +52,5 @@ watchers
 links
 jslinks
 link_plots
-jscallback
+jscallbacks
 ```
diff --git a/doc/how_to/links/watchers.md b/doc/how_to/links/watchers.md
index 2b37346dfa..35983ef7c5 100644
--- a/doc/how_to/links/watchers.md
+++ b/doc/how_to/links/watchers.md
@@ -5,6 +5,8 @@ The ``link`` method used above provides a high-level API to link to parameters,
 To demonstrate ``param.watch``, let us set up three different models: 1) a `Markdown` pane to display the possible options, 2) a ``Markdown`` pane to display the _selected_ options, and 3) a ``ToggleGroup`` widget that allows us to toggle between a number of options:
 
 ```{pyodide}
+import panel as pn
+
 selections = pn.pane.Markdown(object='')
 selected = pn.pane.Markdown(object='')
 toggle = pn.widgets.ToggleGroup(options=['A', 'B'])
diff --git a/doc/how_to/param/custom.md b/doc/how_to/param/custom.md
index ce0e5ee5ad..5ee192e231 100644
--- a/doc/how_to/param/custom.md
+++ b/doc/how_to/param/custom.md
@@ -5,6 +5,9 @@ In the previous section we saw how parameters can automatically be turned into w
 As an example, we can map a string and a number Selector to a `RadioButtonGroup` and `DiscretePlayer` respectively.
 
 ```{pyodide}
+import panel as pn
+import param
+
 class CustomExample(param.Parameterized):
     """An example Parameterized class"""
 
diff --git a/doc/how_to/wasm/index.md b/doc/how_to/wasm/index.md
index d381ca9d0d..9993e4bbdf 100644
--- a/doc/how_to/wasm/index.md
+++ b/doc/how_to/wasm/index.md
@@ -20,7 +20,7 @@ This guide will take you through the process of either
 :link: convert
 :link-type: doc
 
-Discover how to convert existing Panel applications to WASM.
+Discover how to convert existing Panel applications to WebAssembly.
 :::
 
 :::{grid-item-card} {octicon}`code;2.5em;sd-mr-1` Use from WASM

From 7670913f02eae395c89d3e4353b8cb282510a76a Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Wed, 4 Jan 2023 15:45:00 +0100
Subject: [PATCH 09/15] Relabel how to sections

---
 doc/how_to/index.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index 7dd37fbcbe..1b2aee1e03 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -7,21 +7,21 @@ The Panel's How to Guides provide step by step recipes for solving essential pro
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
-:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` APIs
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Choose an API
 :link: apis/index
 :link-type: doc
 
-Discover the different APIs offered by Panel.
+Discover the different APIs offered by Panel and how to choose between them.
 :::
 
-:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Parameters
+:::{grid-item-card} {octicon}`codespaces;2.5em;sd-mr-1` Declaring UIs with parameters
 :link: param/index
 :link-type: doc
 
 Discover how to use Parameters with Panel.
 :::
 
-:::{grid-item-card} {octicon}`link;2.5em;sd-mr-1` Linking Parameters
+:::{grid-item-card} {octicon}`link;2.5em;sd-mr-1` Link Parameters
 :link: links/index
 :link-type: doc
 
@@ -43,14 +43,14 @@ Discover different ways of linking parameters in Python and Javascript.
 How to set up callbacks on session related events and periodic tasks.
 :::
 
-:::{grid-item-card} {octicon}`note;2.5em;sd-mr-1` Accessing session state
+:::{grid-item-card} {octicon}`note;2.5em;sd-mr-1` Access Session State
 :link: state/index
 :link-type: doc
 
 How to access state related to the user session, HTTP request and URL arguments.
 :::
 
-:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Caching
+:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Cache Data
 :link: caching/index
 :link-type: doc
 
@@ -65,21 +65,21 @@ How to cache data across sessions and memoize the output of functions.
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
-:::{grid-item-card} {octicon}`device-desktop;2.5em;sd-mr-1` Display and Preview output
+:::{grid-item-card} {octicon}`device-desktop;2.5em;sd-mr-1` Display and Preview Output
 :link: display/index
 :link-type: doc
 
 How to display Panel components and apps in your favorite notebook or editor environment.
 :::
 
-:::{grid-item-card} {octicon}`file;2.5em;sd-mr-1` Exporting and Saving output
+:::{grid-item-card} {octicon}`file;2.5em;sd-mr-1` Export and Save Output
 :link: export/index
 :link-type: doc
 
 How to export and save Panel applications as static files.
 :::
 
-:::{grid-item-card} {octicon}`browser;2.5em;sd-mr-1` Running in WebAssembly
+:::{grid-item-card} {octicon}`browser;2.5em;sd-mr-1` Run Panel in WebAssembly
 :link: wasm/index
 :link-type: doc
 
@@ -94,28 +94,28 @@ How to run Panel applications entirely in the browser using WebAssembly, Pyodide
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
-:::{grid-item-card} {octicon}`server;2.5em;sd-mr-1` Server Configuration
+:::{grid-item-card} {octicon}`server;2.5em;sd-mr-1` Configure the Server
 :link: server/index
 :link-type: doc
 
 How to configure the Panel server.
 :::
 
-:::{grid-item-card} {octicon}`package-dependencies;2.5em;sd-mr-1` Server Integrations
+:::{grid-item-card} {octicon}`package-dependencies;2.5em;sd-mr-1` Integrate with other Servers
 :link: integrations/index
 :link-type: doc
 
 How to integrate Panel in other application based on Flask, FastAPI or Django.
 :::
 
-:::{grid-item-card} {octicon}`share;2.5em;sd-mr-1` Deploying applications
+:::{grid-item-card} {octicon}`share;2.5em;sd-mr-1` Deploy Applications
 :link: deployment/index
 :link-type: doc
 
 How to deploy Panel applications to various cloud providers (e.g. Azure, GCP, AWS etc.)
 :::
 
-:::{grid-item-card} {octicon}`shield-check;2.5em;sd-mr-1` Authentication
+:::{grid-item-card} {octicon}`shield-check;2.5em;sd-mr-1` Add Authentication
 :link: authentication/index
 :link-type: doc
 

From d4d53469b205e33c927e6fd95769ece10e453ab2 Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Wed, 4 Jan 2023 18:08:10 +0100
Subject: [PATCH 10/15] Reorganize about and api sections

---
 doc/about/{comparisons.rst => comparisons.md} | 21 ++---
 doc/about/index.md                            | 19 +++++
 doc/about/index.rst                           | 17 ----
 doc/{ => about}/releases.md                   |  0
 .../Overview.md => api/cheatsheet.md}         | 84 +------------------
 doc/api/config.md                             | 76 +++++++++++++++++
 doc/api/index.md                              | 75 +++++++++++++++++
 doc/api/index.rst                             | 52 ------------
 doc/api/state.md                              | 79 +++++++++++++++++
 doc/conf.py                                   |  2 +-
 doc/index.md                                  | 17 ++--
 11 files changed, 265 insertions(+), 177 deletions(-)
 rename doc/about/{comparisons.rst => comparisons.md} (98%)
 create mode 100644 doc/about/index.md
 delete mode 100644 doc/about/index.rst
 rename doc/{ => about}/releases.md (100%)
 rename doc/{user_guide/Overview.md => api/cheatsheet.md} (60%)
 create mode 100644 doc/api/config.md
 create mode 100644 doc/api/index.md
 delete mode 100644 doc/api/index.rst
 create mode 100644 doc/api/state.md

diff --git a/doc/about/comparisons.rst b/doc/about/comparisons.md
similarity index 98%
rename from doc/about/comparisons.rst
rename to doc/about/comparisons.md
index 5784e9057b..4ffb1f5ba9 100644
--- a/doc/about/comparisons.rst
+++ b/doc/about/comparisons.md
@@ -1,9 +1,6 @@
-Comparisons
-===========
+# Comparisons
 
-
-Comparing Panel and Bokeh
--------------------------
+## Comparing Panel and Bokeh
 
 Panel and Bokeh can both be used to create dashboards in Python, but are intended for different uses and different audiences:
 
@@ -14,9 +11,7 @@ Panel and Bokeh can both be used to create dashboards in Python, but are intende
 - Bokeh focuses on providing lower-level primitives that can be used to create any dashboard with enough effort, while Panel focuses on making common data-science tasks and making typical types of apps easier.
 
 
-
-Comparing Panel and Dash
-------------------------
+## Comparing Panel and Dash
 
 Panel and Dash can both be used to create dashboards in Python, but take very different approaches:
 
@@ -33,8 +28,7 @@ Panel and Dash can both be used to create dashboards in Python, but take very di
   * Panel's approach makes it easy to do server-side caching of intermediate computations for each user, which can make complex processing pipelines much more responsive. For instance, when used with a Datashader pipeline where the server renders an image from data that is never transmitted to the client, only the stages that have actually changed need to be re-run when a user interacts with the plot, making rendering changes like selecting a colormap almost instantaneous because the already aggregated data can be reused. With Dash, the server does not retain a copy of the intermediate data in such a pipeline, so when a new request comes in, it has to recompute each of the stages even when the data involved has not changed.  The `Datashader example dashboard <https://examples.pyviz.org/datashader_dashboard/dashboard.html>`__ shows how to use this intermediate-value caching to provide the fastest possible updates for a given user action, only re-running the computation actually needed to satisfy the request, re-using cached values stored on the server when appropriate.
 
 
-Comparing Panel and ipywidgets
-------------------------------
+## Comparing Panel and ipywidgets
 
 Both Panel and ipywidgets (aka Jupyter Widgets) allow Python users to work with custom widgets and create apps and dashboards from Python, both in Jupyter notebooks and in standalone servers (when paired with Voila). But Panel and ipywidgets are based on different, independently developed technologies for doing so, with some implications:
 
@@ -51,9 +45,7 @@ Both Panel and ipywidgets (aka Jupyter Widgets) allow Python users to work with
 - As of 9/2020, both types of widgets are now fully interoperable; you can use Panel or Bokeh widgets and panes in an ipywidgets-based app using `jupyter_bokeh <https://github.com/bokeh/jupyter_bokeh>`_ and you can use ipywidgets in a Panel or Bokeh app using `ipywidgets_bokeh <https://github.com/bokeh/ipywidgets_bokeh>`_.  So in practice, you can now mix and match content from either ecosystem as needed, choosing your "native" ecosystem based on other factors like deployment options (see below).
 
 
-
-Comparing Panel and Voila
--------------------------
+## Comparing Panel and Voila
 
 Voila is a technology for deploying Jupyter notebooks (with or without Panel code) as standalone web pages backed by Python. Voila is thus one way you can deploy your Panel apps, your ipywidgets-based apps, or any other content visible in a Jupyter notebook (including multiple languages, like R or C++). Voila is an alternative to the Bokeh Server component that is available through ``panel serve``; Panel works with either one, and you can deploy with *either* Bokeh Server (panel serve) or Voila. To serve a Panel app with Voila, just install `jupyter_bokeh <https://github.com/bokeh/jupyter_bokeh>`__ and do ``pn.ipywidget(panel_obj)``, which makes an ipywidget out of your Panel object that Voila (or Jupyter itself) can then display and let you interact with.
 
@@ -70,8 +62,7 @@ The other major difference between Bokeh Server and Voila is the way they proces
 Panel takes a different approach, in that output from a notebook cell needs to be explicitly wrapped in a Panel object and marked as being "servable"; cell outputs and Markdown cells by default are shown only in the notebook, and not with ``panel serve``. Panel in fact entirely ignores the fact that your notebook is organized into cells; it simply processes all the cells as Python code, and serves all the items that ended up being marked "servable". Although this approach means editing the original notebook before you can see a dashboard, it makes it fully practical for the same notebook to serve both an exploratory or storytelling purpose (in Jupyter) and act as a dashboard deployment (of a designated subset of the functionality). The Panel developers very often use this functionality to provide detailed documentation for any given panel, with the cell-by-cell output showing the dataset, intermediate steps, interesting features, and how-tos, while the final deployed dashboard focuses on the final result, with the content in each case organized to best suit its purpose.
 
 
-Comparing Panel and streamlit
------------------------------
+## Comparing Panel and streamlit
 
 streamlit is an alternative to all of the above packages. Like Jupyter, streamlit provides an interactive, incremental way to build apps. streamlit works with Python text files written in a separate editor, while Jupyter uses a web-based notebook cell editor. Although a web-based editor makes it simple to work locally on remote files, using a local Python text file allows users to maximize their productivity by choosing their own favorite editor. Dash, Panel, and Bokeh all also support bare Python files developed in a local editor, and like streamlit they can all also watch that file and automatically re-run the file when you change it in the editor (e.g. for Panel or Bokeh, launch ``bokeh serve file.py --dev`` to watch the Python file and re-launch the served app on any changes).
 
diff --git a/doc/about/index.md b/doc/about/index.md
new file mode 100644
index 0000000000..8c9f0380ff
--- /dev/null
+++ b/doc/about/index.md
@@ -0,0 +1,19 @@
+# About
+
+Panel is completely open source, available under a BSD license freely for both commercial and non-commercial use. Panel was originally developed with the support of [Anaconda Inc.](https://anaconda.com) using funding from various commercial and government partners, and is now maintained by Anaconda developers and community contributors.
+
+Panel is part of the [HoloViz](https://holoviz.org) family of tools. The [holoviz.org](https://holoviz.org) website shows how to use Panel together with other libraries to solve complex problems, with detailed tutorials and examples. You can see a variety of projects using Panel at [examples.pyviz.org](https://examples.pyviz.org), and you can compare Panel to other available tools at [pyviz.org](https://pyviz.org).
+
+If you have any questions or usage issues visit the [Panel Discourse](https://discourse.holoviz.org/c/panel/) site. If you are interested in contributing to Panel development to help address some of the [open issues](https://github.com/holoviz/panel/issues), see our [developer instructions](https://pyviz-dev.github.io/panel/developer_guide/index.html) to set up your development environment.
+
+If you like Panel and have built something you want to share, tweet a link or screenshot of your latest creation at @Panel_org, along with any other library you used (@HoloViews, @Datashader, @BokehPlots, @Matplotlib, etc.). Thanks!
+
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+releases
+comparisons
+```
diff --git a/doc/about/index.rst b/doc/about/index.rst
deleted file mode 100644
index db2de9963e..0000000000
--- a/doc/about/index.rst
+++ /dev/null
@@ -1,17 +0,0 @@
-About
-=====
-
-Panel is completely open source, available under a BSD license freely for both commercial and non-commercial use. Panel was originally developed with the support of `Anaconda Inc. <https://anaconda.com>`_ using funding from various commercial and government partners, and is now maintained by Anaconda developers and community contributors.
-
-Panel is part of the `HoloViz <https://holoviz.org>`_ family of tools. The `holoviz.org <https://holoviz.org>`_ website shows how to use Panel together with other libraries to solve complex problems, with detailed tutorials and examples. You can see a variety of projects using Panel at `examples.pyviz.org <https://examples.pyviz.org>`_, and you can compare Panel to other available tools at `pyviz.org <https://pyviz.org>`_.
-
-If you have any questions or usage issues visit the `Panel Discourse <https://discourse.holoviz.org/c/panel/>`_ site. If you are interested in contributing to Panel development to help address some of the `open issues <https://github.com/holoviz/panel/issues>`_, see our `developer instructions <https://pyviz-dev.github.io/panel/developer_guide/index.html>`_ to set up your development environment.
-
-If you like Panel and have built something you want to share, tweet a link or screenshot of your latest creation at @Panel_org, along with any other library you used (@HoloViews, @Datashader, @BokehPlots, @Matplotlib, etc.). Thanks!
-
-
-.. toctree::
-   :titlesonly:
-   :maxdepth: 2
-
-   Comparisons <comparisons>
diff --git a/doc/releases.md b/doc/about/releases.md
similarity index 100%
rename from doc/releases.md
rename to doc/about/releases.md
diff --git a/doc/user_guide/Overview.md b/doc/api/cheatsheet.md
similarity index 60%
rename from doc/user_guide/Overview.md
rename to doc/api/cheatsheet.md
index 93dd56f611..43892fbd10 100644
--- a/doc/user_guide/Overview.md
+++ b/doc/api/cheatsheet.md
@@ -1,4 +1,4 @@
-# Overview
+# Cheat Sheet
 
 In order to get the best use out of the Panel user guide, it is important to have a grasp of some core concepts, ideas, and terminology.
 
@@ -131,85 +131,3 @@ One of the most important aspects of a general app and dashboarding framework is
 #### ``.jslink()``
 
 > The JavaScript-based ``.jslink()`` method directly links properties of the underlying Bokeh models, making it possible to define interactivity that works even without a running Python server.
-
-___
-
-## State and configuration
-
-Panel provides top-level objects to hold current state and control high-level configuration variables.
-
-### `pn.config`
-
-The `pn.config` object allows setting various configuration variables, the config variables can also be set as environment variables or passed through the [`pn.extension`](#pn-extension):
-
-#### Python only
-
-> - `css_files`: External CSS files to load.
-> - `js_files`: External JS files to load. Dictionary should map from exported name to the URL of the JS file.
-> - `loading_spinner`: The style of the global loading indicator, e.g. 'arcs', 'bars', 'dots', 'petals'.
-> - `loading_color`: The color of the global loading indicator as a hex color, e.g. #6a6a6a
-> - `defer_load`: Whether reactive function evaluation is deferred until the page is rendered.
-> - `exception_handler`: A custom exception handler can be defined which should accept any exceptions raised while processing events originating from the frontend and onload callbacks.
-> - `nthreads`: If set will start a `ThreadPoolExecutor` to dispatch events to for concurrent execution on separate cores. By default no thread pool is launched, while setting nthreads=0 launches `min(32, os.cpu_count() + 4)` threads.
-> - `raw_css`: List of raw CSS strings to add to load.
-> - `reuse_sessions`: Whether to reuse a session for the initial request to speed up the initial page render. Note that if the initial page differs between sessions, e.g. because it uses query parameters to modify the rendered content, then this option will result in the wrong content being rendered. See the [Performance and Debugging guide](Performance_and_Debugging.rst#Reuse-sessions) for more information.
-> - `safe_embed`: Whether to record all set events when embedding rather than just those that are changed
-> - `session_history`: If set to a non-zero value this determines the maximum length of the pn.state.session_info dictionary, which tracks information about user sessions. A value of -1 indicates an unlimited history.
-> - `sizing_mode`:  Specify the default sizing mode behavior of panels.
-> - `template`: The template to render the served application into, e.g. `'bootstrap'` or `'material'`.
-> - `theme`: The theme to apply to the selected template (no effect unless `template` is set)
-> - `throttled`: Whether sliders and inputs should be throttled until release of mouse.
-
-#### Python and Environment variables
-
-> - `comms` (`PANEL_COMMS`): Whether to render output in Jupyter with the default Jupyter extension or use the `jupyter_bokeh` ipywidget model.
-> - `console_output` (`PANEL_CONSOLE_OUTPUT`): How to log errors and stdout output triggered by callbacks from Javascript in the notebook. Options include `'accumulate'`, `'replace'` and `'disable'`.
-> - `embed` (`PANEL_EMBED`): Whether plot data will be [embedded](./Deploy_and_Export.rst#Embedding).
-> - `embed_json` (`PANEL_EMBED_JSON`): Whether to save embedded state to json files.
-> - `embed_json_prefix` (`PANEL_EMBED_JSON_PREFIX`): Prefix for randomly generated json directories.
-> - `embed_load_path` (`PANEL_EMBED_LOAD_PATH`): Where to load json files for embedded state.
-> - `embed_save_path` (`PANEL_EMBED_SAVE_PATH`): Where to save json files for embedded state.
-> - `inline` (`PANEL_INLINE`): Whether to inline JS and CSS resources. If disabled, resources are loaded from CDN if one is available.
-> - `npm_cdn` (`PANEL_NPM_CDN`): The CDN to load NPM packages from if resources are served from CDN. Allows switching between 'https://unpkg.com' (default) and 'https://cdn.jsdelivr.net/npm' for most resources.
-
-#### `pn.state`
-
-The `pn.state` object makes various global state available and provides methods to manage that state:
-
-- - `access_token`: The access token issued by the OAuth provider to authorize requests to its APIs.
-> - `busy`: A boolean value to indicate whether a callback is being actively processed.
-> - `cache`: A global cache which can be used to share data between different processes.
-> - `cookies`: HTTP request cookies for the current session.
-> - `curdoc`: When running a server session this property holds the current bokeh Document.
-> - `location`: In a server context this provides read and write access to the URL:
->   * `hash`: hash in window.location e.g. '#interact'
->   * `pathname`: pathname in window.location e.g. '/user_guide/Interact.html'
->   * `search`: search in window.location e.g. '?color=blue'
->   * `reload`: Reloads the page when the location is updated.
->   * `href` (readonly): The full url, e.g. 'https://localhost:80?color=blue#interact'
->   * `hostname` (readonly): hostname in window.location e.g. 'panel.holoviz.org'
->   * `protocol` (readonly): protocol in window.location e.g. 'http:' or 'https:'
->   * `port` (readonly): port in window.location e.g. '80'
-> - `headers`: HTTP request headers for the current session.
-> - `refresh_token`: The refresh token issued by the OAuth provider to authorize requests to its APIs (if available these are usually longer lived than the `access_token`).
-> - `session_args`: When running a server session this return the request arguments.
-> - `session_info`: A dictionary tracking information about server sessions:
->   * `total` (int): The total number of sessions that have been opened
->   * `live` (int): The current number of live sessions
->   * `sessions` (dict(str, dict)): A dictionary of session information:
->       * `started`: Timestamp when the session was started
->       * `rendered`: Timestamp when the session was rendered
->       * `ended`: Timestamp when the session was ended
->       * `user_agent`: User-Agent header of client that opened the session
-> - `webdriver`: Caches the current webdriver to speed up export of bokeh models to PNGs.
->
-> #### Methods
->
-> - `add_periodic_callback`: Schedules a periodic callback to be run at an interval set by the period
-> - `as_cached`: Allows caching data across sessions by memoizing on the provided key and keyword arguments to the provided function.
-> - `cancel_scheduled`: Cancel a scheduled task by name.
-> - `execute`: Executes both synchronous and asynchronous callbacks appropriately depending on the context the application is running in.
-> - `kill_all_servers`: Stops all running server sessions.
-> - `onload`: Allows defining a callback which is run when a server is fully loaded
-> - `schedule`: Schedule a callback periodically at a specific time (click [here](./Deploy_and_Export.rst#pn.state.schedule) for more details)
-> - `sync_busy`: Sync an indicator with a boolean value parameter to the busy property on state
diff --git a/doc/api/config.md b/doc/api/config.md
new file mode 100644
index 0000000000..5b7760c59e
--- /dev/null
+++ b/doc/api/config.md
@@ -0,0 +1,76 @@
+# Config
+
+The `pn.config` object allows setting various configuration variables, the config variables can also be set as environment variables or passed through the [`pn.extension`](cheatsheet#pn-extension):
+
+### Python only
+
+`css_files`
+: External CSS files to load.
+
+`js_files`
+: External JS files to load. Dictionary should map from exported name to the URL of the JS file.
+
+`loading_spinner`
+: The style of the global loading indicator, e.g. 'arcs', 'bars', 'dots', 'petals'.
+
+`loading_color`
+: The color of the global loading indicator as a hex color, e.g. #6a6a6a
+
+`defer_load`
+: Whether reactive function evaluation is deferred until the page is rendered.
+
+`exception_handler`
+: A custom exception handler can be defined which should accept any exceptions raised while processing events originating from the frontend and onload callbacks.
+
+`nthreads`
+: If set will start a `ThreadPoolExecutor` to dispatch events to for concurrent execution on separate cores. By default no thread pool is launched, while setting nthreads=0 launches `min(32, os.cpu_count() + 4)` threads.
+
+`raw_css`
+: List of raw CSS strings to add to load.
+
+`reuse_sessions`
+: Whether to reuse a session for the initial request to speed up the initial page render. Note that if the initial page differs between sessions, e.g. because it uses query parameters to modify the rendered content, then this option will result in the wrong content being rendered. See the [Performance and Debugging guide](Performance_and_Debugging.rst#Reuse-sessions) for more information.
+
+`safe_embed`
+: Whether to record all set events when embedding rather than just those that are changed
+
+`session_history`
+: If set to a non-zero value this determines the maximum length of the pn.state.session_info dictionary, which tracks information about user sessions. A value of -1 indicates an unlimited history.
+`sizing_mode`
+:  Specify the default sizing mode behavior of panels.
+
+`template`
+: The template to render the served application into, e.g. `'bootstrap'` or `'material'`.
+
+`theme`
+: The theme to apply to the selected template (no effect unless `template` is set)
+
+`throttled`
+: Whether sliders and inputs should be throttled until release of mouse.
+
+### Python and Environment variables
+
+`comms` (`PANEL_COMMS`)
+: Whether to render output in Jupyter with the default Jupyter extension or use the `jupyter_bokeh` ipywidget model.
+`console_output` (`PANEL_CONSOLE_OUTPUT`): How to log errors and stdout output triggered by callbacks from Javascript in the notebook. Options include `'accumulate'`, `'replace'` and `'disable'`.
+
+`embed` (`PANEL_EMBED`)
+: Whether plot data will be [embedded](./Deploy_and_Export.rst#Embedding).
+
+`embed_json` (`PANEL_EMBED_JSON`)
+: Whether to save embedded state to json files.
+
+`embed_json_prefix` (`PANEL_EMBED_JSON_PREFIX`)
+: Prefix for randomly generated json directories.
+
+`embed_load_path` (`PANEL_EMBED_LOAD_PATH`)
+: Where to load json files for embedded state.
+
+`embed_save_path` (`PANEL_EMBED_SAVE_PATH`)
+: Where to save json files for embedded state.
+
+`inline` (`PANEL_INLINE`)
+: Whether to inline JS and CSS resources. If disabled, resources are loaded from CDN if one is available.
+
+`npm_cdn` (`PANEL_NPM_CDN`)
+: The CDN to load NPM packages from if resources are served from CDN. Allows switching between 'https://unpkg.com' (default) and 'https://cdn.jsdelivr.net/npm' for most resources.
diff --git a/doc/api/index.md b/doc/api/index.md
new file mode 100644
index 0000000000..fd9fd85ef2
--- /dev/null
+++ b/doc/api/index.md
@@ -0,0 +1,75 @@
+# API Reference
+
+The Panel API Reference Manual provides a comprehensive reference for
+all methods and parameters on Panel components. For more information
+on how to use the components see the [Reference Gallery](../reference/index).
+
+## Overview
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Cheat Sheet
+:link: cheatsheet
+:link-type: doc
+
+The Cheat Sheet provides a high-level overview of some of the most important functions in Panel.
+:::
+
+:::{grid-item-card} {octicon}`codespaces;2.5em;sd-mr-1` Config
+:link: config
+:link-type: doc
+
+The `panel.config` provides a way to set high-level configuration options. 
+:::
+
+:::{grid-item-card} {octicon}`link;2.5em;sd-mr-1` State
+:link: state
+:link-type: doc
+
+The `panel.state` object holds session state and provide various methods to attach events and tasks to a session.
+:::
+
+::::
+
+## Module Structure
+
+[`panel.io`](panel.io)
+: Utilities for working with Panel components
+
+[`panel.layout`](panel.layout)
+: Panel layout components
+
+[`panel.pane`](panel.pane)
+: Panel layout components
+
+[`panel.param`](panel.param)
+: Components for integration with the param library
+
+[`panel.pipeline`](panel.pipeline)
+: Panel Pipeline component
+
+[`panel.widgets`](panel.widgets)
+: Widget components
+
+[`panel.viewable`](panel.viewable)
+: Baseclasses for all Panel components
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+cheatsheet
+config
+state
+panel.io
+panel.layout
+panel.pane
+panel.param
+panel.pipeline
+panel.template
+panel.util
+panel.viewable
+panel.widgets
+```
diff --git a/doc/api/index.rst b/doc/api/index.rst
deleted file mode 100644
index c32ae05640..0000000000
--- a/doc/api/index.rst
+++ /dev/null
@@ -1,52 +0,0 @@
-*************
-API Reference
-*************
-
-The Panel API Reference Manual provides a comprehensive reference for
-all methods and parameters on Panel components. For more information
-on how to use the components see the `Reference Gallery
-<../reference>`_.
-
-Module Structure
-________________
-
-Panel subpackages
------------------
-
-`io`_
- Utilities for working with Panel components
-`layout`_
- Panel layout components
-`pane`_
- Panel layout components
-`param`_
- Components for integration with the param library
-`pipeline`_
- Panel Pipeline component
-`widgets`_
- Widget components
-`viewable`_
- Baseclasses for all Panel components
-
-.. toctree::
-   :maxdepth: 2
-   :hidden:
-
-   io <panel.io>
-   layout <panel.layout>
-   pane <panel.pane>
-   param <panel.param>
-   pipeline <panel.pipeline>
-   template <panel.template>
-   widgets <panel.widgets>
-   viewable <panel.viewable>
-   util <panel.util>
-
-.. _io: panel.io.html
-.. _layout: panel.layout.html
-.. _pane: panel.pane.html
-.. _param: panel.param.html
-.. _pipeline: panel.pipeline.html
-.. _template: panel.template.html
-.. _widgets: panel.widgets.html
-.. _viewable: panel.viewable.html
diff --git a/doc/api/state.md b/doc/api/state.md
new file mode 100644
index 0000000000..863267c5e6
--- /dev/null
+++ b/doc/api/state.md
@@ -0,0 +1,79 @@
+# State
+
+The `pn.state` object makes various global state available and provides methods to manage that state.
+
+## Parameters
+
+`access_token`
+: The access token issued by the OAuth provider to authorize requests to its APIs.
+
+`busy`
+: A boolean value to indicate whether a callback is being actively processed.
+
+`cache`
+: A global cache which can be used to share data between different processes.
+
+`cookies`
+: HTTP request cookies for the current session.
+
+`curdoc`
+: When running a server session this property holds the current bokeh Document.
+
+`location`
+: In a server context this provides read and write access to the URL:
+   * `hash`: hash in window.location e.g. '#interact'
+   * `pathname`: pathname in window.location e.g. '/user_guide/Interact.html'
+   * `search`: search in window.location e.g. '?color=blue'
+   * `reload`: Reloads the page when the location is updated.
+   * `href` (readonly): The full url, e.g. 'https://localhost:80?color=blue#interact'
+   * `hostname` (readonly): hostname in window.location e.g. 'panel.holoviz.org'
+   * `protocol` (readonly): protocol in window.location e.g. 'http:' or 'https:'
+   * `port` (readonly): port in window.location e.g. '80'
+
+`headers`
+: HTTP request headers for the current session.
+
+`refresh_token`
+: The refresh token issued by the OAuth provider to authorize requests to its APIs (if available these are usually longer lived than the `access_token`).
+
+`session_args`
+: When running a server session this return the request arguments.
+
+`session_info`
+: A dictionary tracking information about server sessions:
+   * `total` (int): The total number of sessions that have been opened
+   * `live` (int): The current number of live sessions
+   * `sessions` (dict(str, dict)): A dictionary of session information:
+       * `started`: Timestamp when the session was started
+       * `rendered`: Timestamp when the session was rendered
+       * `ended`: Timestamp when the session was ended
+       * `user_agent`: User-Agent header of client that opened the session
+
+`webdriver`
+: Caches the current webdriver to speed up export of bokeh models to PNGs.
+
+## Methods
+
+`add_periodic_callback`
+: Schedules a periodic callback to be run at an interval set by the period
+
+`as_cached`
+: Allows caching data across sessions by memoizing on the provided key and keyword arguments to the provided function.
+
+`cancel_scheduled`
+: Cancel a scheduled task by name.
+
+`execute`
+: Executes both synchronous and asynchronous callbacks appropriately depending on the context the application is running in.
+
+`kill_all_servers`
+: Stops all running server sessions.
+
+`onload`
+: Allows defining a callback which is run when a server is fully loaded
+
+`schedule`
+: Schedule a callback periodically at a specific time (click [here](./Deploy_and_Export.rst#pn.state.schedule) for more details)
+
+`sync_busy`
+: Sync an indicator with a boolean value parameter to the busy property on state
diff --git a/doc/conf.py b/doc/conf.py
index 2f7be6038f..9b3cd9139f 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -73,7 +73,7 @@
 ]
 napoleon_numpy_docstring = True
 
-myst_enable_extensions = ["colon_fence"]
+myst_enable_extensions = ["colon_fence", "deflist"]
 
 nbsite_gallery_conf = {
     'github_org': 'holoviz',
diff --git a/doc/index.md b/doc/index.md
index 1c73534470..d0e5201fca 100644
--- a/doc/index.md
+++ b/doc/index.md
@@ -154,14 +154,13 @@ alt: Blackstone Logo
 :maxdepth: 2
 
 self
-getting_started/index.md
-how_to/index.md
-user_guide/index.rst
-gallery/index.rst
-reference/index.rst
-developer_guide/index.rst
-api/index.rst
-releases.md
-FAQ.rst
+getting_started/index
+how_to/index
+gallery/index
+reference/index
+developer_guide/index
+api/index
+releases
+FAQ
 about/index.rst
 ```

From 0b8d4ca881b861b689e40fb2782c1dd96f926f59 Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Wed, 4 Jan 2023 18:18:55 +0100
Subject: [PATCH 11/15] Various fixes

---
 doc/about/comparisons.md          | 14 +++++++-------
 doc/how_to/callbacks/async.md     |  2 +-
 doc/how_to/deployment/index.md    |  2 +-
 doc/how_to/index.md               |  4 ++--
 doc/how_to/integrations/Django.md |  2 +-
 doc/how_to/links/jslinks.md       |  8 ++++----
 doc/how_to/wasm/standalone.md     |  4 ++--
 7 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/doc/about/comparisons.md b/doc/about/comparisons.md
index 4ffb1f5ba9..dd564167fd 100644
--- a/doc/about/comparisons.md
+++ b/doc/about/comparisons.md
@@ -25,7 +25,7 @@ Panel and Dash can both be used to create dashboards in Python, but take very di
 
   * Dash's approach is more highly scalable in some cases, allowing many simultaneous client sessions without necessarily using up resources on the server for each new client.
 
-  * Panel's approach makes it easy to do server-side caching of intermediate computations for each user, which can make complex processing pipelines much more responsive. For instance, when used with a Datashader pipeline where the server renders an image from data that is never transmitted to the client, only the stages that have actually changed need to be re-run when a user interacts with the plot, making rendering changes like selecting a colormap almost instantaneous because the already aggregated data can be reused. With Dash, the server does not retain a copy of the intermediate data in such a pipeline, so when a new request comes in, it has to recompute each of the stages even when the data involved has not changed.  The `Datashader example dashboard <https://examples.pyviz.org/datashader_dashboard/dashboard.html>`__ shows how to use this intermediate-value caching to provide the fastest possible updates for a given user action, only re-running the computation actually needed to satisfy the request, re-using cached values stored on the server when appropriate.
+  * Panel's approach makes it easy to do server-side caching of intermediate computations for each user, which can make complex processing pipelines much more responsive. For instance, when used with a Datashader pipeline where the server renders an image from data that is never transmitted to the client, only the stages that have actually changed need to be re-run when a user interacts with the plot, making rendering changes like selecting a colormap almost instantaneous because the already aggregated data can be reused. With Dash, the server does not retain a copy of the intermediate data in such a pipeline, so when a new request comes in, it has to recompute each of the stages even when the data involved has not changed.  The [Datashader example dashboard](https://examples.pyviz.org/datashader_dashboard/dashboard.html) shows how to use this intermediate-value caching to provide the fastest possible updates for a given user action, only re-running the computation actually needed to satisfy the request, re-using cached values stored on the server when appropriate.
 
 
 ## Comparing Panel and ipywidgets
@@ -36,20 +36,20 @@ Both Panel and ipywidgets (aka Jupyter Widgets) allow Python users to work with
 
 - ipywidgets expose more of the underlying HTML/CSS styling options, allowing them to be customized more heavily than Bokeh widgets currently allow.
 
-- Panel widgets support easy embedding into static HTML pages for exporting notebooks, while ipywidgets require a separate and cumbersome `"embed widget state" <https://ipywidgets.readthedocs.io/en/latest/embedding.html>`__ operation to copy state from Python into the web page source. Panel widgets are thus easier to use for HTML reports, documentation (e.g. with Sphinx), and other cases where the output needs to be readable or usable without a running Python process.
+- Panel widgets support easy embedding into static HTML pages for exporting notebooks, while ipywidgets require a separate and cumbersome ["embed widget state"](https://ipywidgets.readthedocs.io/en/latest/embedding.html) operation to copy state from Python into the web page source. Panel widgets are thus easier to use for HTML reports, documentation (e.g. with Sphinx), and other cases where the output needs to be readable or usable without a running Python process.
 
-- Where appropriate, Panel supports separating your scientific/engineering/business logic from your GUI implementation, allowing you to declare information that is used to make widgets in a way that is independent of any particular GUI toolkit, web packages, browser, or any other fast-changing technology. Specifically, Panel widgets build on the `Param <https://param.pyviz.org>`__ library that allows capturing the arguments and parameters of functions and classes independently of how the user may later provide or adjust those values. Param lets you specify the name, type, docstring, and range of valid values in a generic way that has no dependencies on any GUI library (or any other library) and allows validating user input in general, not just for a specific dashboard app. Once the parameters have been declared, the code can be used for command-line applications, servers, batch jobs, or (with Panel) generating live, active widgets automatically with no further customization needed to build an app. Param has been in continuous use by multiple libraries since 2003, across many generations of GUI toolkits, and can be expected to adapt to future toolkits as they become available without needing changes to your own domain-specific codebase. Via Param, Panel can thus integrate into a large, long-lived codebase that is used in a variety of different ways at any one time or over its lifetime, such as a simulator or modeling tool, domain-specific analysis libraries, automated processing pipelines, and so on, without ever needing the code to be rewritten or having the GUI code drift out of sync with the business/scientific logic. ipywidgets were designed primarily for the final application or dashboard usage, not for this full life cycle of research or analysis code.
+- Where appropriate, Panel supports separating your scientific/engineering/business logic from your GUI implementation, allowing you to declare information that is used to make widgets in a way that is independent of any particular GUI toolkit, web packages, browser, or any other fast-changing technology. Specifically, Panel widgets build on the [Param](https://param.pyviz.org) library that allows capturing the arguments and parameters of functions and classes independently of how the user may later provide or adjust those values. Param lets you specify the name, type, docstring, and range of valid values in a generic way that has no dependencies on any GUI library (or any other library) and allows validating user input in general, not just for a specific dashboard app. Once the parameters have been declared, the code can be used for command-line applications, servers, batch jobs, or (with Panel) generating live, active widgets automatically with no further customization needed to build an app. Param has been in continuous use by multiple libraries since 2003, across many generations of GUI toolkits, and can be expected to adapt to future toolkits as they become available without needing changes to your own domain-specific codebase. Via Param, Panel can thus integrate into a large, long-lived codebase that is used in a variety of different ways at any one time or over its lifetime, such as a simulator or modeling tool, domain-specific analysis libraries, automated processing pipelines, and so on, without ever needing the code to be rewritten or having the GUI code drift out of sync with the business/scientific logic. ipywidgets were designed primarily for the final application or dashboard usage, not for this full life cycle of research or analysis code.
 
-- Panel widgets are reactive, allowing declarative specification of dependencies between code and widgets (or, more specifically, between code and the Param parameter values inside the widgets). This approach makes it possible to support directly accepting widget objects as arguments to Python code. That way, users never have to write explicit Python callbacks, yet the code will dynamically be executed as needed to respond to user interaction. This programming paradigm can provide highly responsive GUI applications with much less code and much simpler reasoning, as illustrated in the `Datashader widget dashboard <https://anaconda.org/jbednar/dashboard_barewidgets/notebook>`__.
+- Panel widgets are reactive, allowing declarative specification of dependencies between code and widgets (or, more specifically, between code and the Param parameter values inside the widgets). This approach makes it possible to support directly accepting widget objects as arguments to Python code. That way, users never have to write explicit Python callbacks, yet the code will dynamically be executed as needed to respond to user interaction. This programming paradigm can provide highly responsive GUI applications with much less code and much simpler reasoning, as illustrated in the [Datashader widget dashboard](https://anaconda.org/jbednar/dashboard_barewidgets/notebook).
 
-- As of 9/2020, both types of widgets are now fully interoperable; you can use Panel or Bokeh widgets and panes in an ipywidgets-based app using `jupyter_bokeh <https://github.com/bokeh/jupyter_bokeh>`_ and you can use ipywidgets in a Panel or Bokeh app using `ipywidgets_bokeh <https://github.com/bokeh/ipywidgets_bokeh>`_.  So in practice, you can now mix and match content from either ecosystem as needed, choosing your "native" ecosystem based on other factors like deployment options (see below).
+- As of 9/2020, both types of widgets are now fully interoperable; you can use Panel or Bokeh widgets and panes in an ipywidgets-based app using [jupyter_bokeh](https://github.com/bokeh/jupyter_bokeh) and you can use ipywidgets in a Panel or Bokeh app using [ipywidgets_bokeh](https://github.com/bokeh/ipywidgets_bokeh).  So in practice, you can now mix and match content from either ecosystem as needed, choosing your "native" ecosystem based on other factors like deployment options (see below).
 
 
 ## Comparing Panel and Voila
 
-Voila is a technology for deploying Jupyter notebooks (with or without Panel code) as standalone web pages backed by Python. Voila is thus one way you can deploy your Panel apps, your ipywidgets-based apps, or any other content visible in a Jupyter notebook (including multiple languages, like R or C++). Voila is an alternative to the Bokeh Server component that is available through ``panel serve``; Panel works with either one, and you can deploy with *either* Bokeh Server (panel serve) or Voila. To serve a Panel app with Voila, just install `jupyter_bokeh <https://github.com/bokeh/jupyter_bokeh>`__ and do ``pn.ipywidget(panel_obj)``, which makes an ipywidget out of your Panel object that Voila (or Jupyter itself) can then display and let you interact with.
+Voila is a technology for deploying Jupyter notebooks (with or without Panel code) as standalone web pages backed by Python. Voila is thus one way you can deploy your Panel apps, your ipywidgets-based apps, or any other content visible in a Jupyter notebook (including multiple languages, like R or C++). Voila is an alternative to the Bokeh Server component that is available through ``panel serve``; Panel works with either one, and you can deploy with *either* Bokeh Server (panel serve) or Voila. To serve a Panel app with Voila, just install [jupyter_bokeh](https://github.com/bokeh/jupyter_bokeh) and do ``pn.ipywidget(panel_obj)``, which makes an ipywidget out of your Panel object that Voila (or Jupyter itself) can then display and let you interact with.
 
-Similarly, widgets and plots that use ipywidgets, such as ipyvolume, ipyleaflet, or bqplot, can be used in your Panel app and deployed with Bokeh/Panel Server without needing Voila, as long as you have installed `ipywidgets_bokeh <https://github.com/bokeh/ipywidgets_bokeh>`_.
+Similarly, widgets and plots that use ipywidgets, such as ipyvolume, ipyleaflet, or bqplot, can be used in your Panel app and deployed with Bokeh/Panel Server without needing Voila, as long as you have installed [ipywidgets_bokeh](https://github.com/bokeh/ipywidgets_bokeh).
 
 So, how do you choose between using Voila or Bokeh server if you are using Panel objects? Both servers are based on Tornado under the hood, but they differ in the fact that Jupyter will launch a new Python kernel for each user, while the Bokeh server can serve multiple users on the same process. This subtle difference has two major implications:
 
diff --git a/doc/how_to/callbacks/async.md b/doc/how_to/callbacks/async.md
index fded26f089..fb5c6492d2 100644
--- a/doc/how_to/callbacks/async.md
+++ b/doc/how_to/callbacks/async.md
@@ -1,4 +1,4 @@
-## Asynchronous callbacks
+# Asynchronous callbacks
 
 Python has natively supported asynchronous functions since version 3.5, for a quick overview of some of the concepts involved see [the Python documentation](https://docs.python.org/3/library/asyncio-task.html). For full asyncio support in Panel you will have to use `python>=3.8`.
 
diff --git a/doc/how_to/deployment/index.md b/doc/how_to/deployment/index.md
index e922dc3f52..536345e0ae 100644
--- a/doc/how_to/deployment/index.md
+++ b/doc/how_to/deployment/index.md
@@ -44,7 +44,7 @@ For guides on running and configuring a Panel server see the [server how-to guid
 
 ::::
 
-#### Other Cloud Providers
+## Other Cloud Providers
 
 Panel can be used with just about any cloud provider that can launch a Python process, including Amazon Web Services (AWS) and DigitalOcean. The Panel developers will add documentation for these services as they encounter them in their own work, but we would greatly appreciate step-by-step instructions from users working on each of these systems.
 
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index 1b2aee1e03..22a3c9f19d 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -14,11 +14,11 @@ The Panel's How to Guides provide step by step recipes for solving essential pro
 Discover the different APIs offered by Panel and how to choose between them.
 :::
 
-:::{grid-item-card} {octicon}`codespaces;2.5em;sd-mr-1` Declaring UIs with parameters
+:::{grid-item-card} {octicon}`codespaces;2.5em;sd-mr-1` Declare UIs with parameters
 :link: param/index
 :link-type: doc
 
-Discover how to use Parameters with Panel.
+Discover how to use Parameters with Panel to automatically generate UIs without writing GUI code.
 :::
 
 :::{grid-item-card} {octicon}`link;2.5em;sd-mr-1` Link Parameters
diff --git a/doc/how_to/integrations/Django.md b/doc/how_to/integrations/Django.md
index 32db02d883..3174d417d6 100644
--- a/doc/how_to/integrations/Django.md
+++ b/doc/how_to/integrations/Django.md
@@ -117,7 +117,7 @@ The sliders app is in `examples/apps/django/sliders`. We will cover the followin
 
   * `sliders/views.py` and `templates/base.html`: getting the Bokeh app into a Django view
 
-![screenshot of sliders app](../_static/sliders.png)
+![screenshot of sliders app](../../_static/sliders.png)
 
 To start with, in `sliders/sinewave.py` we create a parameterized object to serve as a placeholder for your own, existing code:
 
diff --git a/doc/how_to/links/jslinks.md b/doc/how_to/links/jslinks.md
index 1de17cd434..dacdc46ed6 100644
--- a/doc/how_to/links/jslinks.md
+++ b/doc/how_to/links/jslinks.md
@@ -4,7 +4,7 @@ Linking objects in Python is often very convenient, because it allows writing co
 
 To begin with let us see how we can express simple links between standard Panel components before digging into some more specific and complex examples.
 
-### Linking model properties
+## Linking model properties
 
 Let us start by rehashing the example from above, linking the ``value`` of the ``TextInput`` widget to the ``object`` property of the ``Markdown`` pane:
 
@@ -21,7 +21,7 @@ pn.Row(text_input, markdown)
 
 As you can see the signature is identical to the ``link`` example above, but here Panel translates the specification into a JS code snippet which syncs the properties on the underlying Bokeh properties. But now if you edit the widget and press Return, the Markdown display will automatically update even in a static HTML web page.
 
-### Linking bi-directionally
+## Linking bi-directionally
 
 When you want the source and target to be linked bi-directionally, i.e. a change in one will automatically trigger a change in the other you can simply set the `bidirectional` argument:
 
@@ -35,7 +35,7 @@ t1.jslink(t2, value='value', bidirectional=True)
 pn.Row(t1, t2)
 ```
 
-### Linking using custom JS code
+## Linking using custom JS code
 
 Since everything happens in JS for a `jslink`, we can't provide a Python callback. Instead, we can define a JS code snippet, which is executed when a property changes. E.g. we can define a little code snippet which adds HTML bold tags (``<b>``) around the text before setting it on the target. The code argument should map from the parameter/property on the source object to the JS code snippet to execute:
 
@@ -61,7 +61,7 @@ Of course, you can still update the value from Python, and it will automatically
 text_input.value = "Markdown display"
 ```
 
-### Open URL
+## Open URL
 
 As an example of using `jslink`, here we open a URL from the ``TextInput`` widget value. A new browser tab will open with the provided URL:
 
diff --git a/doc/how_to/wasm/standalone.md b/doc/how_to/wasm/standalone.md
index af64e74d68..aad15f454e 100644
--- a/doc/how_to/wasm/standalone.md
+++ b/doc/how_to/wasm/standalone.md
@@ -51,9 +51,9 @@ To get started with Pyodide simply follow their [Getting started guide](https://
 
 The app should look like this
 
-![Panel Pyodide App](../_static/images/pyodide_app_simple.png)
+![Panel Pyodide App](../../_static/images/pyodide_app_simple.png)
 
-:::{admonition}
+:::{admonition} warn
 The default bokeh and panel packages are very large, therefore we recommend you pip install specialized wheels:
 
 ```javascript

From 4c51f3f0fd62bdd5a4856a12389a9fb159a18e38 Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Wed, 4 Jan 2023 19:11:06 +0100
Subject: [PATCH 12/15] Add display sections

---
 doc/how_to/display/editor.md                 |   3 +
 doc/how_to/display/index.md                  |  42 +++-
 doc/how_to/display/jupyterlab.md             |   3 +
 doc/how_to/display/notebook.md               |  89 ++++++++
 doc/how_to/index.md                          |  45 +++--
 examples/user_guide/Display_and_Export.ipynb | 201 -------------------
 6 files changed, 159 insertions(+), 224 deletions(-)
 create mode 100644 doc/how_to/display/editor.md
 create mode 100644 doc/how_to/display/jupyterlab.md
 create mode 100644 doc/how_to/display/notebook.md
 delete mode 100644 examples/user_guide/Display_and_Export.ipynb

diff --git a/doc/how_to/display/editor.md b/doc/how_to/display/editor.md
new file mode 100644
index 0000000000..c7d95fc87a
--- /dev/null
+++ b/doc/how_to/display/editor.md
@@ -0,0 +1,3 @@
+# Develop Apps in an Editor
+
+WIP
\ No newline at end of file
diff --git a/doc/how_to/display/index.md b/doc/how_to/display/index.md
index 92af613dc0..f42d981a2a 100644
--- a/doc/how_to/display/index.md
+++ b/doc/how_to/display/index.md
@@ -1 +1,41 @@
-# Display and Preview Output
+# Display Components and Apps
+
+One of the main design goals for Panel was that it should make it possible to seamlessly transition back and forth between interactively prototyping a dashboard in the notebook or on the commandline to deploying it as a standalone server app.
+
+This guide will provide simple how-to guides on how to display panels interactively in a notebook or in your favorite editor environment.
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Display output in notebooks
+:link: notebook
+:link-type: doc
+
+How to display output in Jupyter and non-Jupyter based notebook environments.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Develop Apps in an Editor
+:link: editor
+:link-type: doc
+
+Discover how to rapidly develop a Panel application in your favorite IDE or editor.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Develop Apps in JupyterLab
+:link: jupyterlab
+:link-type: doc
+
+How to use the Preview functionality in JupyterLab to rapidly develop applications.
+:::
+
+::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+notebook
+editor
+jupyterlab
+```
\ No newline at end of file
diff --git a/doc/how_to/display/jupyterlab.md b/doc/how_to/display/jupyterlab.md
new file mode 100644
index 0000000000..9a3df2a205
--- /dev/null
+++ b/doc/how_to/display/jupyterlab.md
@@ -0,0 +1,3 @@
+# Develop Apps in JupyterLab
+
+WIP
\ No newline at end of file
diff --git a/doc/how_to/display/notebook.md b/doc/how_to/display/notebook.md
new file mode 100644
index 0000000000..49600f3496
--- /dev/null
+++ b/doc/how_to/display/notebook.md
@@ -0,0 +1,89 @@
+# Display Output in Notebooks
+
+Once you have installed Panel it should automatically set up class Jupyter notebook and JupyterLab extensions for rendering Panel output and configuring communication channels to ensure the rendered output syncs bi-directionally with the Python process.
+
+## Loading the extension
+
+The first step when working in a notebook environment should always be to load the `panel.extension`:
+
+```{pyodide}
+import panel as pn
+
+pn.extension()
+```
+
+The extension ensures that all required Javascript and CSS resources are added to your notebook environment. If you are going to be using any custom extensions, such as [Vega](../../reference/panes/Vega) or [Tabulator](../../reference/widgets/Tabulator) you must ensure that you initialize these as well:
+
+```{pyodide}
+pn.extension('vega', 'tabulator')
+```
+
+## Display output
+
+One of the major benefits of notebook environments is that they support rich output. This means that if you place an object with rich output at the end of a cell the notebook will figure out how to render the rich representation. Panel uses this mechanism to ensure that all components return a rich representation: 
+
+```{pyodide}
+pane = pn.panel('<marquee>Here is some custom HTML</marquee>')
+
+pane
+```
+
+To instead see a textual representation of the component, you can use the ``pprint`` method on any Panel object:
+
+```{pyodide}
+pane.pprint()
+```
+
+### The ``display`` function
+
+To avoid having to put a Panel on the last line of a notebook cell, e.g. to display it from inside a function call, you can use the IPython built-in ``display`` function:
+
+```{pyodide}
+def display_marquee(text):
+    display(pn.panel('<marquee>{text}</marquee>'.format(text=text)))
+    
+display_marquee('This Panel was displayed from within a function')
+```
+
+## Render as ipywidget
+
+While Jupyter Notebook and JupyterLab support rendering arbitrary MIME types many other notebook environments (such as VSCode notebooks) only support bi-directional communication channels when rendering an IPyWidget. Therefore Panel provides a compatibility wrapper that makes it possible to wrap a Panel component in an IPywidget. To enable ipywidgets support globally you can set the `comms` option:
+
+```python
+pn.extension(comms='ipywidgets')
+# or
+pn.config.comms = 'ipywidgets'
+```
+
+Note that this happens automatically when running Panel inside VSCode and Google Colab but may be needed in other notebook environments. This global setting can also be useful when trying to serve an entire notebook using [Voilà](https://github.com/voila-dashboards/voila). Alternatively, we can convert individual objects to an ipywidget one at a time using the `pn.ipywidget()` function:
+
+```python
+ipywidget = pn.ipywidget(pane)
+ipywidget
+```
+
+This approach also allows combining a Panel object with any other Jupyter-widget--based model:
+
+```python
+from ipywidgets import Accordion
+Accordion(children=[pn.ipywidget(pane)])
+```
+
+To use Panel's ipywidgets support in JupyterLab, the following extensions have to be installed:
+ 
+```
+jupyter labextension install @jupyter-widgets/jupyterlab-manager
+jupyter labextension install @bokeh/jupyter_bokeh
+```
+
+Additionally the `jupyter_bokeh` package should be installed using either pip:
+
+```
+pip install jupyter_bokeh
+```
+
+or using conda:
+
+```
+conda install -c bokeh jupyter_bokeh
+```
\ No newline at end of file
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index 22a3c9f19d..8e3c02250d 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -31,59 +31,59 @@ Discover different ways of linking parameters in Python and Javascript.
 ::::
 
 
-## Advanced
+## Display and Export
 
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
-:::{grid-item-card} {octicon}`zap;2.5em;sd-mr-1` Session callbacks and events
-:link: callbacks/index
+:::{grid-item-card} {octicon}`device-desktop;2.5em;sd-mr-1` Display Components and Apps
+:link: display/index
 :link-type: doc
 
-How to set up callbacks on session related events and periodic tasks.
+How to display Panel components and effectively develop apps in your favorite notebook or editor environment.
 :::
 
-:::{grid-item-card} {octicon}`note;2.5em;sd-mr-1` Access Session State
-:link: state/index
+:::{grid-item-card} {octicon}`file;2.5em;sd-mr-1` Export and Save Output
+:link: export/index
 :link-type: doc
 
-How to access state related to the user session, HTTP request and URL arguments.
+How to export and save Panel applications as static files.
 :::
 
-:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Cache Data
-:link: caching/index
+:::{grid-item-card} {octicon}`browser;2.5em;sd-mr-1` Run Panel in WebAssembly
+:link: wasm/index
 :link-type: doc
 
-How to cache data across sessions and memoize the output of functions.
+How to run Panel applications entirely in the browser using WebAssembly, Pyodide and PyScript.
 :::
 
 ::::
 
 
-## Display and Export
+## Advanced
 
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
-:::{grid-item-card} {octicon}`device-desktop;2.5em;sd-mr-1` Display and Preview Output
-:link: display/index
+:::{grid-item-card} {octicon}`zap;2.5em;sd-mr-1` Register session callbacks
+:link: callbacks/index
 :link-type: doc
 
-How to display Panel components and apps in your favorite notebook or editor environment.
+How to set up callbacks on session related events (e.g. on page load or when a session is destroyed) and define periodic tasks.
 :::
 
-:::{grid-item-card} {octicon}`file;2.5em;sd-mr-1` Export and Save Output
-:link: export/index
+:::{grid-item-card} {octicon}`note;2.5em;sd-mr-1` Access Session State
+:link: state/index
 :link-type: doc
 
-How to export and save Panel applications as static files.
+How to access state related to the user session, HTTP request and URL arguments.
 :::
 
-:::{grid-item-card} {octicon}`browser;2.5em;sd-mr-1` Run Panel in WebAssembly
-:link: wasm/index
+:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Cache Data
+:link: caching/index
 :link-type: doc
 
-How to run Panel applications entirely in the browser using WebAssembly, Pyodide and PyScript.
+How to cache data across sessions and memoize the output of functions.
 :::
 
 ::::
@@ -133,11 +133,12 @@ How to configure OAuth to add authentication to a server deployment.
 apis/index
 param/index
 links/index
+display/index
+export/index
+wasm/index
 callbacks/index
 state/index
 caching/index
-export/index
-wasm/index
 server/index
 integrations/index
 deployment/index
diff --git a/examples/user_guide/Display_and_Export.ipynb b/examples/user_guide/Display_and_Export.ipynb
deleted file mode 100644
index 11526e819f..0000000000
--- a/examples/user_guide/Display_and_Export.ipynb
+++ /dev/null
@@ -1,201 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import panel as pn\n",
-    "\n",
-    "pn.extension()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "One of the main design goals for Panel was that it should make it possible to seamlessly transition back and forth between interactively prototyping a dashboard in the notebook or on the commandline to deploying it as a standalone server app. This section shows how to display panels interactively, embed static output, save a snapshot, and deploy as a separate web-server app. For more information about deploying Panel apps to various cloud providers see the [Server Deployment](Server_Deployment.ipynb) documentation.\n",
-    "\n",
-    "## Configuring output\n",
-    "\n",
-    "As you may have noticed, almost all the Panel documentation is written using notebooks. Panel objects display themselves automatically in a notebook and take advantage of Jupyter Comms to support communication between the rendered app and the Jupyter kernel that backs it on the Python end. To display a Panel object in the notebook is as simple as putting it on the end of a cell. Note, however, that the ``panel.extension`` first has to be loaded to initialize the required JavaScript in the notebook context. In recent versions of JupyterLab this works out of the box but for older versions (`<3.0`) the PyViz labextension has to be installed with:\n",
-    "\n",
-    "    jupyter labextension install @pyviz/jupyterlab_pyviz\n",
-    "\n",
-    "### Optional dependencies\n",
-    "\n",
-    "Also remember that in order to use certain components such as Vega, LaTeX, and Plotly plots in a notebook, the models must be loaded using the extension. If you forget to load the extension, you should get a warning reminding you to do it. To load certain JS components, simply list them as part of the call to ``pn.extension``:\n",
-    "\n",
-    "    pn.extension('vega', 'katex')\n",
-    "\n",
-    "Here we've ensured that the Vega and LaTeX JS dependencies will be loaded.\n",
-    "\n",
-    "### Initializing JS and CSS \n",
-    "\n",
-    "Additionally, any external ``css_files``, ``js_files`` and ``raw_css`` needed should be declared in the extension. The ``js_files`` should be declared as a dictionary mapping from the exported JS module name to the URL containing the JS components, while the ``css_files`` can be defined as a list:\n",
-    "\n",
-    "    pn.extension(js_files={'deck': https://unpkg.com/deck.gl@~5.2.0/deckgl.min.js},\n",
-    "                 css_files=['https://api.tiles.mapbox.com/mapbox-gl-js/v0.44.1/mapbox-gl.css'])\n",
-    "\n",
-    "The ``raw_css`` argument allows defining a list of strings containing CSS to publish as part of the notebook and app.\n",
-    "\n",
-    "Providing keyword arguments via the ``extension`` is the same as setting them on ``pn.config``, which is the preferred approach outside the notebook. ``js_files`` and ``css_files`` may be set to your chosen values as follows:\n",
-    "\n",
-    "    pn.config.js_files  = {'deck': 'https://unpkg.com/deck.gl@~5.2.0/deckgl.min.js'}\n",
-    "    pn.config.css_files = ['https://api.tiles.mapbox.com/mapbox-gl-js/v0.44.1/mapbox-gl.css']"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Display in the notebook\n",
-    "\n",
-    "#### The repr\n",
-    "    \n",
-    "Once the extension is loaded, Panel objects will display themselves if placed at the end of cell in the notebook:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pane = pn.panel('<marquee>Here is some custom HTML</marquee>')\n",
-    "\n",
-    "pane"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To instead see a textual representation of the component, you can use the ``pprint`` method on any Panel object:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pane.pprint()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### The ``display`` function\n",
-    "\n",
-    "To avoid having to put a Panel on the last line of a notebook cell, e.g. to display it from inside a function call, you can use the IPython built-in ``display`` function:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def display_marquee(text):\n",
-    "    display(pn.panel('<marquee>{text}</marquee>'.format(text=text)))\n",
-    "    \n",
-    "display_marquee('This Panel was displayed from within a function')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Inline apps\n",
-    "\n",
-    "Lastly it is also possible to display a Panel object as a Bokeh server app inside the notebook.  To do so call the ``.app`` method on the Panel object and provide the URL of your notebook server:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pane.app('localhost:8888')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The app will now run on a Bokeh server instance separate from the Jupyter notebook kernel, allowing you to quickly test that all the functionality of your app works both in a notebook and in a server context."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ipywidgets\n",
-    "\n",
-    "If the `jupyter_bokeh` package is installed it is also possible to render Panel objects as an ipywidget rather than using Bokeh's internal communication mechanisms.  You can enable ipywidgets support  globally using:\n",
-    "\n",
-    "```python\n",
-    "pn.extension(comms='ipywidgets')\n",
-    "# or\n",
-    "pn.config.comms = 'ipywidgets'\n",
-    "```\n",
-    "\n",
-    "This global setting can be useful when trying to serve an entire notebook using [Voilà](https://github.com/voila-dashboards/voila). Alternatively, we can convert individual objects to an ipywidget one at a time using the `pn.ipywidget()` function:\n",
-    "\n",
-    "```python\n",
-    "ipywidget = pn.ipywidget(pane)\n",
-    "ipywidget\n",
-    "```\n",
-    "\n",
-    "This approach also allows combining a Panel object with any other Jupyter-widget--based model:\n",
-    "\n",
-    "```python\n",
-    "from ipywidgets import Accordion\n",
-    "Accordion(children=[pn.ipywidget(pane)])\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To use Panel's ipywidgets support in JupyterLab, the following extensions have to be installed:\n",
-    "    \n",
-    "```\n",
-    "jupyter labextension install @jupyter-widgets/jupyterlab-manager\n",
-    "jupyter labextension install @bokeh/jupyter_bokeh\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Additionally the `jupyter_bokeh` package should be installed using either pip:\n",
-    "\n",
-    "```\n",
-    "pip install jupyter_bokeh\n",
-    "```\n",
-    "\n",
-    "or using conda:\n",
-    "\n",
-    "```\n",
-    "conda install -c bokeh jupyter_bokeh\n",
-    "```"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python",
-   "pygments_lexer": "ipython3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

From 2fbead0135249557c0b9be74de07b5407b78197d Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Thu, 5 Jan 2023 12:50:42 +0100
Subject: [PATCH 13/15] Add performance, profiling and scaling guides

---
 .../assets => doc/_static}/admin_logs.png     | Bin
 .../assets => doc/_static}/admin_overview.png | Bin
 .../_static}/launch_profiler.png              | Bin
 .../assets => doc/_static}/user_profiling.png | Bin
 doc/how_to/apis/index.md                      |   2 +-
 doc/how_to/concurrency/async.md               |  39 +++
 doc/how_to/concurrency/index.md               |  74 +++++
 doc/how_to/concurrency/load_balancing.md      |  12 +
 doc/how_to/concurrency/manual_threading.md    |  44 +++
 doc/how_to/concurrency/processes.md           |   5 +
 doc/how_to/concurrency/threading.md           |  43 +++
 doc/how_to/index.md                           |  28 +-
 doc/how_to/performance/index.md               |  31 ++
 doc/how_to/performance/layout.md              |  21 ++
 doc/how_to/performance/throttling.md          |  14 +
 doc/how_to/profiling/admin.md                 |   7 +
 doc/how_to/profiling/index.md                 |  39 +++
 doc/how_to/profiling/logs.md                  |  12 +
 doc/how_to/profiling/profile.md               |  52 +++
 doc/user_guide/index.rst                      |  25 --
 .../user_guide/Async_and_Concurrency.ipynb    | 171 ----------
 .../Performance_and_Debugging.ipynb           | 309 ------------------
 22 files changed, 420 insertions(+), 508 deletions(-)
 rename {examples/assets => doc/_static}/admin_logs.png (100%)
 rename {examples/assets => doc/_static}/admin_overview.png (100%)
 rename {examples/assets => doc/_static}/launch_profiler.png (100%)
 rename {examples/assets => doc/_static}/user_profiling.png (100%)
 create mode 100644 doc/how_to/concurrency/async.md
 create mode 100644 doc/how_to/concurrency/index.md
 create mode 100644 doc/how_to/concurrency/load_balancing.md
 create mode 100644 doc/how_to/concurrency/manual_threading.md
 create mode 100644 doc/how_to/concurrency/processes.md
 create mode 100644 doc/how_to/concurrency/threading.md
 create mode 100644 doc/how_to/performance/index.md
 create mode 100644 doc/how_to/performance/layout.md
 create mode 100644 doc/how_to/performance/throttling.md
 create mode 100644 doc/how_to/profiling/admin.md
 create mode 100644 doc/how_to/profiling/index.md
 create mode 100644 doc/how_to/profiling/logs.md
 create mode 100644 doc/how_to/profiling/profile.md
 delete mode 100644 examples/user_guide/Async_and_Concurrency.ipynb
 delete mode 100644 examples/user_guide/Performance_and_Debugging.ipynb

diff --git a/examples/assets/admin_logs.png b/doc/_static/admin_logs.png
similarity index 100%
rename from examples/assets/admin_logs.png
rename to doc/_static/admin_logs.png
diff --git a/examples/assets/admin_overview.png b/doc/_static/admin_overview.png
similarity index 100%
rename from examples/assets/admin_overview.png
rename to doc/_static/admin_overview.png
diff --git a/examples/assets/launch_profiler.png b/doc/_static/launch_profiler.png
similarity index 100%
rename from examples/assets/launch_profiler.png
rename to doc/_static/launch_profiler.png
diff --git a/examples/assets/user_profiling.png b/doc/_static/user_profiling.png
similarity index 100%
rename from examples/assets/user_profiling.png
rename to doc/_static/user_profiling.png
diff --git a/doc/how_to/apis/index.md b/doc/how_to/apis/index.md
index 45ab75e002..1770ff2e79 100644
--- a/doc/how_to/apis/index.md
+++ b/doc/how_to/apis/index.md
@@ -9,7 +9,7 @@ Panel can be used to make a first pass at an app or dashboard in minutes, while
 :link: reactive
 :link-type: doc
 
-Linking functions or methods to widgets using ``pn.bind`` or the equivalent ``pn.depends`` decorator, declaring that the function should be re-run when those widget values change.
+Linking functions or methods to widgets using ``pn.bind`` or the equivalent ``pn.depends`` decorator.
 :::
 
 :::{grid-item-card} Interact functions
diff --git a/doc/how_to/concurrency/async.md b/doc/how_to/concurrency/async.md
new file mode 100644
index 0000000000..278528a276
--- /dev/null
+++ b/doc/how_to/concurrency/async.md
@@ -0,0 +1,39 @@
+# Use Asynchronous Processing
+
+When using Python>=3.8 you can use async callbacks wherever you would ordinarily use a regular synchronous function. For instance you can use `pn.bind` on an async function:
+
+```{pyodide}
+import aiohttp
+import panel as pn
+
+widget = pn.widgets.IntSlider(start=0, end=10)
+
+async def get_img(index):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"https://picsum.photos/800/300?image={index}") as resp:
+            return pn.pane.JPG(await resp.read())
+            
+pn.Column(widget, pn.bind(get_img, widget))
+```
+
+In this example Panel will invoke the function and update the output when the function returns while leaving the process unblocked for the duration of the `aiohttp` request. 
+
+Similarly you can attach asynchronous callbacks using `.param.watch`:
+
+```{pyodide}
+widget = pn.widgets.IntSlider(start=0, end=10)
+
+image = pn.pane.JPG()
+
+async def update_img(event):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"https://picsum.photos/800/300?image={event.new}") as resp:
+            image.object = await resp.read()
+            
+widget.param.watch(update_img, 'value')
+widget.param.trigger('value')
+            
+pn.Column(widget, image)
+```
+
+In this example Param will await the asynchronous function and the image will be updated when the request completes.
\ No newline at end of file
diff --git a/doc/how_to/concurrency/index.md b/doc/how_to/concurrency/index.md
new file mode 100644
index 0000000000..ccc3ea2209
--- /dev/null
+++ b/doc/how_to/concurrency/index.md
@@ -0,0 +1,74 @@
+# Add concurrent processing
+
+When deploying a Panel application to be accessed by multiple users they will often access the same server simultaneously. To maintain responsiveness of the application when multiple users are interacting with it at the same time there are multiple approaches to concurrency, each with their own drawbacks and advantages:
+
+1. `Load balancing`: A load balancer distributes network traffic between multiple instances of the Panel application. This ensures that the load is distributed across multiple servers but also requires a lot configuration and resources.
+2. `Multi-process server instance`: Launches your app with multiple processes on a single machine. Much simpler to set up than a load balancer but the load is not distributed equally across processes and you are limited by the compute and memory resources on one machine.
+2. `Threading`: Attempts to distribute processing across multiple threads. Effectiveness depends on the operations being performed, I/O bound and CPU bound operations that release the GIL can easily be made concurrent in this way. 
+3. `AsyncIO`: Allows asynchronously processing I/O bound operations. Effective for many concurrent I/O operations but requires rewriting your application and callbacks to make use of `async`/`await` paradigm.
+
+## Scaling across processes
+
+Both load balancing and starting multiple processes effectively spin up multiple copies of the same application and distribute the load across the processes. This results in duplication and therefore significantly higher overhead (basically scaling linearly with the number of processes). In applications where you are relying on global state (e.g. the `pn.state.cache`) this can introduce significant challenges to ensure that application state stays synchronized.
+
+::::{grid} 1 2 2 2
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Set up Load Balancing
+:link: load_balancing
+:link-type: doc
+
+Discover how-to configure load balancing (e.g. using NGINX) to scale Panel apps across processes.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Launch multiple processes
+:link: processes
+:link-type: doc
+
+Discover how to launch multiple processes on a Panel server to add scaling.
+:::
+
+::::
+
+## Scaling within a single process
+
+Threading and async are both approaches to speed up processing in Python using concurrency in a single Python process. Since we can't provide a complete primer on either threading or asynchronous processing here, if you are not familiar with these concepts we recommend reading up on them before continuing. Read about [threading in Python here](https://realpython.com/intro-to-python-threading/) and [AsyncIO here](https://realpython.com/async-io-python/).
+
+When to use which approach cannot be answered easily and is never completely clear cut. As a general guide however use `asyncio` can scale almost arbitrarily allowing you to perform thousands or even millions of IO bound operations concurrently, while threading  limits you to the number of available threads. In practice this may never actually become relevant so the other main differences are that `async` coroutines are significantly more lightweight but that you have to carefully consider accessing shared objects across threads. Using `async` coroutines makes it very clear where concurrency occurs and therefore can make it easier to avoid race conditions and avoid having to think about locking a thread to access shared objects. However, in some situations threading can also be useful for CPU intensive operations where the operation being executed [releases the GIL](https://realpython.com/python-gil/), this includes many NumPy, Pandas and Numba functions.
+
+::::{grid} 1 2 2 3
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Enable Automatic Threading
+:link: load_balancing
+:link-type: doc
+
+Discover how to enable threading to distribute processing across threads.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Set up Manual Threading
+:link: load_balancing
+:link-type: doc
+
+Discover how to manually set up a Thread to process an event queue.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Use Asynchronous Processing
+:link: processes
+:link-type: doc
+
+Discover how to make use of asynchronous callbacks to handle I/O bound operations concurrently.
+:::
+
+::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+load_balancing
+processes
+threading
+async
+```
\ No newline at end of file
diff --git a/doc/how_to/concurrency/load_balancing.md b/doc/how_to/concurrency/load_balancing.md
new file mode 100644
index 0000000000..04ac6372f1
--- /dev/null
+++ b/doc/how_to/concurrency/load_balancing.md
@@ -0,0 +1,12 @@
+# Load balancing
+
+Setting up load balancing is a huge topic dependent on the precise system you are using so we won't go into any specific implementation here. In most cases you set up a reverse proxy (like NGINX) to distribute the load across multiple application servers. If you are using a system like Kubernetes it will also handle spinning up the servers for you and can even do so dynamically depending on the amount of concurrent users to ensure that you are not wasting resources when there are fewer users.
+
+<figure>
+<img src="https://www.nginx.com/wp-content/uploads/2014/07/what-is-load-balancing-diagram-NGINX-1024x518.png" width="768"></img>
+<figcaption>Diagram showing concept of load balacing (NGINX)</figcaption>
+</figure>
+
+Load balancing is the most complex approach to set up but is guaranteed to improve concurrent usage of your application since different users are not contending for access to the same process or even necessarily the same physical compute and memory resources. At the same time it is more wasteful of resources since it potentially occupies multiple machines and since each process is isolated there is no sharing of cached data or global state.
+
+To get started configuring a load balancer take a look at the [Bokeh documentation](https://docs.bokeh.org/en/latest/docs/user_guide/server/deploy.html#load-balancing) which provides example configurations for Apache and NGINX.
diff --git a/doc/how_to/concurrency/manual_threading.md b/doc/how_to/concurrency/manual_threading.md
new file mode 100644
index 0000000000..d777789543
--- /dev/null
+++ b/doc/how_to/concurrency/manual_threading.md
@@ -0,0 +1,44 @@
+# Set up Manual Threading
+
+Enabling threading in Panel like we saw in the [automatic threading guide](threading) is a simple way to achieve concurrency, however sometimes we need more control. Below we will demonstrate an example of a `Thread` which we start in the background to process items we put in a queue for processing. We simulate the processing with a `time.sleep` but it could be any long-running computation. The `threading.Condition` allows us to manipulate the global shared `queue`.
+
+```python
+import time
+import threading
+
+c = threading.Condition()
+
+button = pn.widgets.Button(name='Click to launch')
+text = pn.widgets.StaticText()
+
+queue = []
+
+def callback():
+    global queue
+    while True:
+        c.acquire()
+        for i, event in enumerate(queue):
+            text.value = f'Processing item {i+1} of {len(queue)} items in queue.'
+	    ... # Do something with the event
+            time.sleep(2)
+        queue.clear()
+        text.value = "Queue empty"
+        c.release()
+        time.sleep(1)
+        
+thread = threading.Thread(target=callback)
+thread.start()
+```
+
+Now we will create a callback that puts new items for processing on the queue when a button is clicked:
+
+```python
+def on_click(event):
+    queue.append(event)
+
+button.on_click(on_click)
+
+pn.Row(button, text).servable()
+```
+
+Since the processing happens on a separate thread the application itself can still remain responsive to further user input (such as putting new items on the queue).
\ No newline at end of file
diff --git a/doc/how_to/concurrency/processes.md b/doc/how_to/concurrency/processes.md
new file mode 100644
index 0000000000..7d27e8c454
--- /dev/null
+++ b/doc/how_to/concurrency/processes.md
@@ -0,0 +1,5 @@
+# Launch multiple processes
+
+Launching a Panel application on multiple processes is effectively a simpler way to scale your application. One major advantage is that it is easy to set up, when deploying your application with `panel serve` simply configure `--num-procs N`, where N is the number of processes. Generally choose an `N` that is no larger than the number of processors on your machine.
+
+The main limitation is that the underlying Tornado multi-process mode does not balance connections across processes. Rather, any incoming connection will be assigned to the first server process that accepts it. Typically any idle process can get a new client regardless of how many clients it already has. In general the resulting distribution of clients across processes will be unequal. Moreover, this still uses significantly more resources since each process has the same overhead and all processes will be contending for the same memory and compute resources. However if your application is single-threaded and you have sufficient memory this is a simple way to make your application scale.
\ No newline at end of file
diff --git a/doc/how_to/concurrency/threading.md b/doc/how_to/concurrency/threading.md
new file mode 100644
index 0000000000..7aba9cfc03
--- /dev/null
+++ b/doc/how_to/concurrency/threading.md
@@ -0,0 +1,43 @@
+# Enable Automatic Threading
+
+Using threading in Panel can either be enabled manually, e.g. by managing your own thread pool and dispatching concurrent tasks to it, or it can be managed by Panel itself by setting the `config.nthreads` parameter (or equivalently by setting it with `pn.extension(nthreads=...)`. This will start a `ThreadPoolExecutor` with the specified number of threads (or if set to `0` it will set the number of threads based on your system, i.e. `min(32, os.cpu_count() + 4)`). 
+
+Whenever an event is generated or a periodic callback fires Panel will then automatically dispatch the event to the executor. An event in this case refers to any action generated on the frontend such as the manipulation of a widget by a user or the interaction with a plot. If you are launching an application with `panel serve` you should enable this option configure this option on the CLI by setting `--num-threads`.
+
+To demonstrate the effect of enabling threading take this example below:
+
+```python
+import panel as pn
+
+pn.extension(nthreads=2)
+
+def button_click(event):
+    print('Button clicked for the {event.new}th time.')
+    time.sleep(2) # Simulate long running operation
+    print('Finished processing {event.new}th click.')
+    
+button = pn.widgets.Button(name='Click me!')
+
+button.on_click(button_click)
+```
+
+When we click the button twice successively in a single-threaded context we will see the following output:
+
+```
+> Button clicked for the 1th time.
+... 2 second wait
+> Finished processing 1th click.
+> Button clicked for the 2th time.
+... 2 second wait
+> Finished processing 2th click.
+```
+
+In a threaded context on the other hand the two clicks will be processed concurrently:
+
+```
+> Button clicked for the 1th time.
+> Button clicked for the 2th time.
+... 2 second wait
+> Finished processing 1th click.
+> Finished processing 2th click.
+```
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index 8e3c02250d..ecc054dfd7 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -1,6 +1,6 @@
 # How-to Guide
 
-The Panel's How to Guides provide step by step recipes for solving essential problems and tasks. They are more advanced than the Getting Started material and assume some knowledge of how Panel works.
+The Panel How-to Guides provide step by step recipes for solving essential problems and tasks. They are more advanced than the Getting Started material and assume some knowledge of how Panel works.
 
 ## Basics
 
@@ -65,7 +65,7 @@ How to run Panel applications entirely in the browser using WebAssembly, Pyodide
 ::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
-:::{grid-item-card} {octicon}`zap;2.5em;sd-mr-1` Register session callbacks
+:::{grid-item-card} {octicon}`zap;2.5em;sd-mr-1` Register Session Callbacks
 :link: callbacks/index
 :link-type: doc
 
@@ -86,6 +86,27 @@ How to access state related to the user session, HTTP request and URL arguments.
 How to cache data across sessions and memoize the output of functions.
 :::
 
+:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Improve Performance
+:link: concurrency/index
+:link-type: doc
+
+Discover some tips and tricks instructing you on how you can improve the performance of your application.
+:::
+
+:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Improve Scalability
+:link: concurrency/index
+:link-type: doc
+
+Discover various approaches telling you how to improve the scalability of your Panel application.
+:::
+
+:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Enable Profiling & Debugging
+:link: profiling/index
+:link-type: doc
+
+Discover how to profile and debug your application using the admin dashboard and other tools.
+:::
+
 ::::
 
 
@@ -139,6 +160,9 @@ wasm/index
 callbacks/index
 state/index
 caching/index
+performance/index
+concurrency/index
+profiling/index
 server/index
 integrations/index
 deployment/index
diff --git a/doc/how_to/performance/index.md b/doc/how_to/performance/index.md
new file mode 100644
index 0000000000..a008862ef9
--- /dev/null
+++ b/doc/how_to/performance/index.md
@@ -0,0 +1,31 @@
+# Improve the Performance
+
+There are a number of common bottlenecks and pitfalls that can significantly reduce the performance of your applications and some approaches to improve the performance of your application. This section provides various approaches to try to improve the performance of your applications.
+
+::::{grid} 1 2 2 2
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Optimize Layouts
+:link: layout
+:link-type: doc
+
+Discover how to split up layouts in a template to avoid bottlenecks with Bokeh's layout engine.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Enable throttling
+:link: processes
+:link-type: doc
+
+Discover how to enable throttling to reduce the number of events being processed.
+:::
+
+::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+layout
+throttling
+```
\ No newline at end of file
diff --git a/doc/how_to/performance/layout.md b/doc/how_to/performance/layout.md
new file mode 100644
index 0000000000..ecc23ca590
--- /dev/null
+++ b/doc/how_to/performance/layout.md
@@ -0,0 +1,21 @@
+# Optimize Layouts
+
+Panel is built on the Bokeh library which was originally written as a plotting library but grew into a more general framework for building data apps and dashboards. This history shows up in some architectural decisions and the main one is the way layouts are handled by Bokeh. Instead of relying on CSS to configure and compute the layouts Bokeh (and therefore Panel) rely on a layout engine which computes the sizes of different components to apply fixed positioning on the page. This works well but is an expensive operation and scales imperfectly the more components are added to a layout. In future, i.e. with the upcoming Bokeh 3.0 and Panel 1.0 releases the layout engine will be replaced with a CSS based framework. Until that time there are a few tricks to apply to avoid the layout engine degrading the performance of your application:
+
+The main approach to avoid bogging down the layout engine is to leverage [Templates](./Templates.ipynb) and add components as separate "roots" to the page. This means that instead of adding components to a layout like this:
+
+```python
+pn.Column(a, b, c, ...)
+```
+
+You add them as separate roots to the template:
+
+```python
+template = pn.template.BootstrapTemplate()
+
+template.main.append(a)
+template.main.append(b)
+template.main.append(c)
+```
+
+Doing this will ensure that the Bokeh.js layout engine considers each component separately and will speed up rendering a lot if `a`, `b` and `c` are deeply nested components.
\ No newline at end of file
diff --git a/doc/how_to/performance/throttling.md b/doc/how_to/performance/throttling.md
new file mode 100644
index 0000000000..0dcdb008c2
--- /dev/null
+++ b/doc/how_to/performance/throttling.md
@@ -0,0 +1,14 @@
+# Enable Throttling
+
+One of the simplest ways to avoid slowing down your application is simply to control how often events from the frontend trigger code execution in Python. Particularly when using sliders this can be a problem. To solve this isssue sliders offer `value_throttled` parameters which are updated only when the user releases the slider unlike the `value` parameter which is updated continuously as the slider is dragged. If you are building apps using the reactive `pn.bind` or `pn.depends` functions you can depend on the `value_throttled` parameter directly:
+
+```python
+slider = pn.widgets.IntSlider()
+
+def output(value):
+    return ...
+
+pn.bind(output, slider.param.value_throttled)
+```
+
+Alternatively you can also ensure that all sliders only update on mouse release if you set `pn.config.throttled = True`.
\ No newline at end of file
diff --git a/doc/how_to/profiling/admin.md b/doc/how_to/profiling/admin.md
new file mode 100644
index 0000000000..ee7809b54e
--- /dev/null
+++ b/doc/how_to/profiling/admin.md
@@ -0,0 +1,7 @@
+# Enable the Admin Panel
+
+The `/admin` panel provides an overview of the current application and provides tools for debugging and profiling. It can be enabled by passing the ``--admin`` argument to the `panel serve` command.
+
+When you have successfully enabled it you should be able to visit the `/admin` endpoint of your application, e.g. if you are serving locally on port 5006, visit `http://localhost:5006/admin`. You should now be greeted with the overview page, which provides some details about currently active sessions, running versions and resource usage (if `psutil` is installed):
+
+<img src="../../_static/admin_overview.png" width="70%"></img>
\ No newline at end of file
diff --git a/doc/how_to/profiling/index.md b/doc/how_to/profiling/index.md
new file mode 100644
index 0000000000..3d4b05c6a1
--- /dev/null
+++ b/doc/how_to/profiling/index.md
@@ -0,0 +1,39 @@
+# Enable Profiling & Debugging
+
+When trying to understand the performance profiles or track down issues with an application the server logs are rarely sufficient to gain insights. For that reason Panel ships with an admin dashboard that allows tracking resource usage, user behavior, and provides ways of visualizing profiling output to discover bottlenecks in an application.
+
+::::{grid} 1 2 2 2
+:gutter: 1 1 1 2
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Enable the Admin Panel
+:link: load_balancing
+:link-type: doc
+
+Discover how-to enable the admin Panel to begin monitoring resource usage and user behavior.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Profile your Application
+:link: processes
+:link-type: doc
+
+Discover how to enable profilers like snakeviz or memray to track down bottlenecks in your application.
+:::
+
+:::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` View Application Logs
+:link: processes
+:link-type: doc
+
+Discover how to view application logs in the admin dashboard.
+:::
+
+::::
+
+```{toctree}
+:titlesonly:
+:hidden:
+:maxdepth: 2
+
+admin
+profile
+logs
+```
\ No newline at end of file
diff --git a/doc/how_to/profiling/logs.md b/doc/how_to/profiling/logs.md
new file mode 100644
index 0000000000..7689797ce9
--- /dev/null
+++ b/doc/how_to/profiling/logs.md
@@ -0,0 +1,12 @@
+# View Application Logs
+
+The Logs page provides a detailed breakdown of the user interaction with the application. Additionally users may also log to this logger using the `pn.state.log` function, e.g. in this example we log the arguments to the clustering function:
+
+```python
+def get_clusters(x, y, n_clusters):
+    pn.state.log(f'clustering {x!r} vs {y!r} into {n_clusters} clusters.')
+    ...
+    return ...
+```
+
+<img src="../../_static/admin_logs.png" width="80%"></img>
\ No newline at end of file
diff --git a/doc/how_to/profiling/profile.md b/doc/how_to/profiling/profile.md
new file mode 100644
index 0000000000..cadfa760e2
--- /dev/null
+++ b/doc/how_to/profiling/profile.md
@@ -0,0 +1,52 @@
+# Profile your Application
+
+If you have [enabled the admin dashboard](admin) you will be able to start profiling your application. Profiling provides ways of analyzing where the bottlenecks of your application are both in terms of execution time and memory usage.
+
+## Launch profiling
+
+The launch profiler profiles the execution time of the initialization of a particular application. It can be enabled by setting a profiler using the commandline ``--profiler`` option to `panel serve`. Available profilers include:
+
+- [`pyinstrument`](https://pyinstrument.readthedocs.io): A statistical profiler with nice visual output
+- [`snakeviz`](https://jiffyclub.github.io/snakeviz/): SnakeViz is a browser based graphical viewer for the output of Python’s cProfile module and an alternative to using the standard library pstats module.
+- [`memray`](https://bloomberg.github.io/memray/): memray is a memory profiler for Python. It can track memory allocations in Python code, in native extension modules, and in the Python interpreter itself.
+
+Once enabled the launch profiler will profile each application separately and provide the profiler output generated by the selected profiling engine.
+
+<img src="../../_static/launch_profiler.png" width="80%"></img>
+
+## User profiling
+
+In addition to profiling the launch step of an application it is often also important to get insight into the interactive performance of an application. For that reason Panel also provides the `pn.io.profile` decorator that can be added to any callback and will report the profiling results in the `/admin` panel. The `profile` helper takes to arguments, the name to record the profiling results under and the profiling `engine` to use.
+
+```python
+@pn.io.profile('clustering', engine='snakeviz')
+def get_clustering(event):
+    # some expensive calculation
+    ...
+    
+widget.param.watch(my_callback, 'value')
+```
+
+<img src="../../_static/user_profiling.png" width="80%"></img>
+
+The user profiling may also be used in an interactive session, e.g. we might decorate a simple callback with the `profile` decorator:
+
+```python
+import time
+
+slider = pn.widgets.FloatSlider(name='Test')
+
+@pn.depends(slider)
+@pn.io.profile('formatting')
+def format_value(value):
+    time.sleep(1)
+    return f'Value: {value+1}'
+
+pn.Row(slider, format_value)
+```
+
+Then we can request the named profile 'formatting' using the `pn.state.get_profile` function:
+
+```python
+pn.state.get_profile('formatting')
+```
\ No newline at end of file
diff --git a/doc/user_guide/index.rst b/doc/user_guide/index.rst
index e55ee9886d..fe76bdbf8b 100644
--- a/doc/user_guide/index.rst
+++ b/doc/user_guide/index.rst
@@ -13,9 +13,6 @@ To get an initial understanding of the core concepts and components of Panel and
 how to use it in practice, it is recommended that all users go through each of
 the core guide sections.
 
-`Overview <Overview.html>`_
- A high-level overview of the key concepts behind Panel.
-
 `Components <Components.html>`_
  An introduction to the three main component types: Widgets, Panes, and Panels.
 
@@ -41,21 +38,6 @@ when needed.
 `Pipelines <Pipelines.html>`_
  Using Parameterized classes to declare linear workflows containing multiple panels.
 
-`Performance, Profiling and Debugging <Performance_and_Debugging.html>`_
- Learn how to speed up your application and find issues.
-
-State, Caching & Callbacks
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-`Asynchronous and Concurrent Processing <Async_and_Concurrency.html>`_
- Learn how leverage asynchronous and concurrent processing to make your app more responsive.
-
-Export
-^^^^^^
-
-`Display & Export <Display_and_Export.html>`_
- Guide towards configuring and displaying output and exporting Panel apps and components.
-
 Extending Panel
 ^^^^^^^^^^^^^^^
 
@@ -67,17 +49,10 @@ Extending Panel
     :hidden:
     :maxdepth: 2
 
-    Overview <Overview>
     Components <Components>
-    APIs <APIs>
     Customization <Customization>
     Interact <Interact>
     Widgets <Widgets>
-    Parameters <Param>
-    Linking <Links>
     Pipelines <Pipelines>
     Templates <Templates>
-    Performance and Debugging <Performance_and_Debugging>
-    Asynchronous and Concurrent Process <Async_and_Concurrency>
-    Display & Export <Display_and_Export>
     Building Custom Components <Custom_Components>
diff --git a/examples/user_guide/Async_and_Concurrency.ipynb b/examples/user_guide/Async_and_Concurrency.ipynb
deleted file mode 100644
index 88c1425347..0000000000
--- a/examples/user_guide/Async_and_Concurrency.ipynb
+++ /dev/null
@@ -1,171 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import panel as pn\n",
-    "import asyncio\n",
-    "\n",
-    "pn.extension()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "User applications frequently have to do multiple tasks at the same time such as processing user input, making I/O requests or running long running calcultions. At the same time the application should continue to responsive to user input. This problem can be solved in a number of different ways and here we will look primarily at two approaches, asynchronous callbacks and concurrency using multiple threads."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Asynchronous functions\n",
-    "\n",
-    "Python has natively supported asynchronous functions since version 3.5, for a quick overview of some of the concepts involved see [the Python documentation](https://docs.python.org/3/library/asyncio-task.html). For full asyncio support in Panel you will have to use `python>=3.8`.\n",
-    "\n",
-    "One of the major benefits of leveraging async functions is that it is simple to write callbacks which will perform some longer running IO tasks in the background. Below we simulate this by creating a `Button` which will update some text when it starts and finishes running a long-running background task (here simulated using `asyncio.sleep`. If you are running this in the notebook you will note that you can start multiple tasks and it will update the text immediately but continue in the background:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "button = pn.widgets.Button(name='Click me!')\n",
-    "text = pn.widgets.StaticText()\n",
-    "\n",
-    "async def run_async(event):\n",
-    "    text.value = f'Running {event.new}'\n",
-    "    await asyncio.sleep(2)\n",
-    "    text.value = f'Finished {event.new}'\n",
-    "\n",
-    "button.on_click(run_async)\n",
-    "\n",
-    "pn.Row(button, text)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that `on_click` is simple one way of registering an asynchronous callback, using `.param.watch` is also supported and so is scheduling asynchronous periodic callbacks with `pn.state.add_periodic_callback`.\n",
-    "\n",
-    "It is important to note that asynchronous callbacks operate without locking the underlying bokeh Document, which means Bokeh models cannot be safely modified by default. Usually this is not an issue because modifying Panel components appropriately schedules updates to underlying Bokeh models, however in cases where we want to modify a Bokeh model directly, e.g. when embedding and updating a Bokeh plot in a Panel application we explicitly have to decorate the asynchronous callback with `pn.io.with_lock`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "from bokeh.plotting import figure\n",
-    "from bokeh.models import ColumnDataSource\n",
-    "\n",
-    "button = pn.widgets.Button(name='Click me!')\n",
-    "\n",
-    "p = figure(width=500, height=300)\n",
-    "cds = ColumnDataSource(data={'x': [0], 'y': [0]})\n",
-    "p.line(x='x', y='y', source=cds)\n",
-    "pane = pn.pane.Bokeh(p)\n",
-    "\n",
-    "@pn.io.with_lock\n",
-    "async def stream(event):\n",
-    "    await asyncio.sleep(1)\n",
-    "    x, y = cds.data['x'][-1], cds.data['y'][-1]\n",
-    "    cds.stream({'x': list(range(x+1, x+6)), 'y': y+np.random.randn(5).cumsum()})\n",
-    "    pane.param.trigger('object')\n",
-    "    \n",
-    "# Equivalent to `.on_click` but shown\n",
-    "button.param.watch(stream, 'clicks')\n",
-    "\n",
-    "pn.Row(button, pane)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Concurrency\n",
-    "\n",
-    "Asynchronous processing can be very helpful for IO bound tasks, however if you have to perform actual computations it won't help you at all since those tasks will continue to block the running thread. It is also not always easy or possible to peform all IO bound tasks asynchronously. Therefore threading can be a very valuable tool in your toolbox. \n",
-    "\n",
-    "Below we will demonstrate an example of a Thread which we start in the background to process items we put in a queue for processing. We simulate the processing with a `time.sleep` but it could be any long-running computation. The `threading.Condition` allows us to manipulate the global shared `queue`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import time\n",
-    "import threading\n",
-    "\n",
-    "c = threading.Condition()\n",
-    "\n",
-    "button = pn.widgets.Button(name='Click to launch')\n",
-    "text = pn.widgets.StaticText()\n",
-    "\n",
-    "queue = []\n",
-    "\n",
-    "def callback():\n",
-    "    global queue\n",
-    "    while True:\n",
-    "        c.acquire()\n",
-    "        for i, q in enumerate(queue):\n",
-    "            text.value = f'Processing item {i+1} of {len(queue)} items in queue.'\n",
-    "            time.sleep(2)\n",
-    "        queue.clear()\n",
-    "        text.value = \"Queue empty\"\n",
-    "        c.release()\n",
-    "        time.sleep(1)\n",
-    "        \n",
-    "thread = threading.Thread(target=callback)\n",
-    "thread.start()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now we will create a callback that puts new items for processing on the queue when a button is clicked:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def on_click(event):\n",
-    "    queue.append(event)\n",
-    "\n",
-    "button.on_click(on_click)\n",
-    "\n",
-    "pn.Row(button, text).servable()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Since the processing happens on a separate thread the application itself can still remain responsive to further user input (such as putting new items on the queue)."
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python",
-   "pygments_lexer": "ipython3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/examples/user_guide/Performance_and_Debugging.ipynb b/examples/user_guide/Performance_and_Debugging.ipynb
deleted file mode 100644
index 9acc6636d3..0000000000
--- a/examples/user_guide/Performance_and_Debugging.ipynb
+++ /dev/null
@@ -1,309 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import panel as pn\n",
-    "pn.extension('tabulator')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "When developing applications that are to be used by multiple users and which may process a lot of data it is important to ensure the application is well optimized. Additionally complex applications may have very complex callbacks which are difficult to trace and debug. In this user guide section we will walk you some of the best practices to debug your applications and profile your application to maximize performance."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Layouts\n",
-    "\n",
-    "Panel is built on the Bokeh library which was originally written as a plotting library but grew into a more general framework for building data apps and dashboards. This history shows up in some architectural decisions and the main one is the way layouts are handled by Bokeh. Instead of relying on CSS to configure and compute the layouts Bokeh (and therefore Panel) rely on a layout engine which computes the sizes of different components to apply fixed positioning on the page. This works well but is an expensive operation and scales imperfectly the more components are added to a layout. In future, i.e. with the upcoming Bokeh 3.0 and Panel 1.0 releases the layout engine will be replaced with a CSS based framework. Until that time there are a few tricks to apply to avoid the layout engine degrading the performance of your application:\n",
-    "\n",
-    "The main approach to avoid bogging down the layout engine is to use [Templates](./Templates.ipynb) and add components as separate \"roots\" to the page. This means that instead of adding components to a layout like this:\n",
-    "\n",
-    "```python\n",
-    "pn.Column(a, b, c, ...)\n",
-    "```\n",
-    "\n",
-    "You add them as separate roots to the template:\n",
-    "\n",
-    "```python\n",
-    "template = pn.template.BootstrapTemplate()\n",
-    "\n",
-    "template.main.append(a)\n",
-    "template.main.append(b)\n",
-    "template.main.append(c)\n",
-    "```\n",
-    "\n",
-    "Doing this will ensure that the Bokeh.js layout engine considers each component separately and will speed up rendering a lot if `a`, `b` and `c` are deeply nested components."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Throttling\n",
-    "\n",
-    "One of the simplest ways to avoid slowing down your application is simply to control how often events from the frontend trigger code execution in Python. Particularly when using sliders this can be a problem. To solve this isssue sliders offer `value_throttled` parameters which are updated only when the user releases the slider unlike the `value` parameter which is updated continuously as the slider is dragged. If you are building apps using the reactive `pn.bind` or `pn.depends` functions you can depend on the `value_throttled` parameter directly:\n",
-    "\n",
-    "```python\n",
-    "slider = pn.widgets.IntSlider()\n",
-    "\n",
-    "def output(value):\n",
-    "    return ...\n",
-    "\n",
-    "pn.bind(output, slider.param.value_throttled)\n",
-    "```\n",
-    "\n",
-    "Alternatively you can also ensure that all sliders only update on mouse release if you set `pn.config.throttled = True`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Concurrent processing\n",
-    "\n",
-    "When deploying a Panel application to be accessed by multiple users they will often access the same server simultaneously. To maintain responsiveness of the application when multiple users are interacting with it at the same time there are multiple approaches to concurrency, each with their own drawbacks and advantages:\n",
-    "\n",
-    "1. `Load balancing`: A load balancer distributes network traffic between multiple instances of the Panel application. This ensures that the load is distributed across multiple servers but also requires a lot configuration and resources.\n",
-    "2. `Multi-process server instance`: Launches your app with multiple processes on a single machine. Much simpler to set up than a load balancer but the load is not distributed equally across processes and you are limited by the compute and memory resources on one machine.\n",
-    "2. `Threading`: Attempts to distribute processing across multiple threads. Effectiveness depends on the operations being performed, I/O bound and CPU bound operations that release the GIL can easily be made concurrent in this way. \n",
-    "3. `AsyncIO`: Allows asynchronously processing I/O bound operations. Effective for many concurrent I/O operations but requires rewriting your application and callbacks to make use of `async`/`await` paradigm.\n",
-    "\n",
-    "### Scaling across processes\n",
-    "\n",
-    "Both load balancing and starting multiple processes effectively spin up multiple copies of the same application and distribute the load across the processes. This results in duplication and therefore significantly higher overhead (basically scaling linearly with the number of processes). In applications where you are relying on global state (e.g. the `pn.state.cache`) this can introduce significant challenges to ensure that application state stays synchronized.\n",
-    "\n",
-    "#### Load balancing\n",
-    "\n",
-    "Setting up load balancing is a huge topic dependent on the precise system you are using so we won't go into any specific implementation here. In most cases you set up a reverse proxy (like NGINX) to distribute the load across multiple application servers. If you are using a system like Kubernetes it will also handle spinning up the servers for you and can even do so dynamically depending on the amount of concurrent users to ensure that you are not wasting resources when there are fewer users.\n",
-    "\n",
-    "<figure>\n",
-    "<img src=\"https://www.nginx.com/wp-content/uploads/2014/07/what-is-load-balancing-diagram-NGINX-1024x518.png\" width=\"768\"></img>\n",
-    "<figcaption>Diagram showing concept of load balacing (NGINX)</figcaption>\n",
-    "</figure>\n",
-    "\n",
-    "Load balancing is the most complex approach to set up but is guaranteed to improve concurrent usage of your application since different users are not contending for access to the same process or even necessarily the same physical compute and memory resources. At the same time it is more wasteful of resources since it potentially occupies multiple machines and since each process is isolated there is no sharing of cached data or global state. \n",
-    "\n",
-    "#### Multi-process server instance\n",
-    "\n",
-    "Launching a Panel application on multiple processes is effectively a simpler way to scale your app. One major advantage is that it is easy to set up, when deploying your application with `panel serve` simply configure `--num-procs N`, where N is the number of processes. Generally choose an `N` that is no larger than the number of processors on your machine.\n",
-    "\n",
-    "The main limitation is that the underlying Tornado multi-process mode does not balance connections across processes. Rather, any incoming connection will be assigned to the first server process that accepts it. Typically any idle process can get a new client regardless of how many clients it already has. In general the resulting distribution of clients across processes will be unequal. Moreover, this still uses significantly more resources since each process has the same overhead and all processes will be contending for the same memory and compute resources. However if your application is single-threaded and you have sufficient memory this is a simple way to make your application scale.\n",
-    "\n",
-    "### Scaling within a single process\n",
-    "\n",
-    "Threading and async are both approaches to speed up processing in Python using concurrency in a single Python process. Since we can't provide a complete primer on either threading or asynchronous processing here, if you are not familiar with these concepts we recommend reading up on them before continuing. Read about [threading in Python here](https://realpython.com/intro-to-python-threading/) and [AsyncIO here](https://realpython.com/async-io-python/).\n",
-    "\n",
-    "When to use which approach cannot be answered easily and is never completely clear cut. As a general guide however use `asyncio` can scale almost arbitrarily allowing you to perform thousands or even millions of IO bound operations concurrently, while threading  limits you to the number of available threads. In practice this may never actually become relevant so the other main differences are that `async` coroutines are significantly more lightweight but that you have to carefully consider accessing shared objects across threads. Using `async` coroutines makes it very clear where concurrency occurs and therefore can make it easier to avoid race conditions and avoid having to think about locking a thread to access shared objects. However, in some situations threading can also be useful for CPU intensive operations where the operation being executed [releases the GIL](https://realpython.com/python-gil/), this includes many NumPy, Pandas and Numba functions.\n",
-    "\n",
-    "### Threading\n",
-    "\n",
-    "Using threading in Panel can either be enabled manually, e.g. by managing your own thread pool and dispatching concurrent tasks to it, or it can be managed by Panel itself by setting the `config.nthreads` parameter (or equivalently by setting it with `pn.extension(nthreads=...)`. This will start a `ThreadPoolExecutor` with the specified number of threads (or if set to `0` it will set the number of threads based on your system, i.e. `min(32, os.cpu_count() + 4)`). \n",
-    "\n",
-    "Whenever an event is generated or a periodic callback fires Panel will then automatically dispatch the event to the executor. An event in this case refers to any action generated on the frontend such as the manipulation of a widget by a user or the interaction with a plot. If you are launching an application with `panel serve` you should enable this option configure this option on the CLI by setting `--num-threads`.\n",
-    "\n",
-    "To demonstrate the effect of enabling threading take this example below:\n",
-    "\n",
-    "```python\n",
-    "import panel as pn\n",
-    "\n",
-    "pn.extension(nthreads=2)\n",
-    "\n",
-    "def button_click(event):\n",
-    "    print('Button clicked for the {event.new}th time.')\n",
-    "    time.sleep(2) # Simulate long running operation\n",
-    "    print('Finished processing {event.new}th click.')\n",
-    "    \n",
-    "button = pn.widgets.Button(name='Click me!')\n",
-    "\n",
-    "button.on_click(button_click)\n",
-    "```\n",
-    "\n",
-    "When we click the button twice successively in a single-threaded context we will see the following output:\n",
-    "\n",
-    "```\n",
-    "> Button clicked for the 1th time.\n",
-    "... 2 second wait\n",
-    "> Finished processing 1th click.\n",
-    "> Button clicked for the 2th time.\n",
-    "... 2 second wait\n",
-    "> Finished processing 2th click.\n",
-    "```\n",
-    "\n",
-    "In a threaded context on the other hand the two clicks will be processed concurrently:\n",
-    "\n",
-    "```\n",
-    "> Button clicked for the 1th time.\n",
-    "> Button clicked for the 2th time.\n",
-    "... 2 second wait\n",
-    "> Finished processing 1th click.\n",
-    "> Finished processing 2th click.\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Admin Panel\n",
-    "\n",
-    "The `/admin` panel provides an overview of the current application and provides tools for debugging and profiling. It can be enabled by passing the ``--admin`` argument to the `panel serve` command."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Overview\n",
-    "\n",
-    "The overview page provides some details about currently active sessions, running versions and resource usage (if `psutil` is installed).\n",
-    "\n",
-    "<img src=\"../assets/admin_overview.png\" width=\"70%\"></img>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Launch Profiler\n",
-    "\n",
-    "The launch profiler profiles the execution time of the initialization of a particular application. It can be enabled by setting a profiler using the commandline ``--profiler`` option. Available profilers include:\n",
-    "\n",
-    "- [`pyinstrument`](https://pyinstrument.readthedocs.io): A statistical profiler with nice visual output\n",
-    "- [`snakeviz`](https://jiffyclub.github.io/snakeviz/): SnakeViz is a browser based graphical viewer for the output of Python’s cProfile module and an alternative to using the standard library pstats module.\n",
-    "- [`memray`](https://bloomberg.github.io/memray/): memray is a memory profiler for Python. It can track memory allocations in Python code, in native extension modules, and in the Python interpreter itself.\n",
-    "\n",
-    "Once enabled the launch profiler will profile each application separately and provide the profiler output generated by the selected profiling engine.\n",
-    "\n",
-    "<img src=\"../assets/launch_profiler.png\" width=\"80%\"></img>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### User profiling\n",
-    "\n",
-    "In addition to profiling the launch step of an application it is often also important to get insight into the interactive performance of an application. For that reason Panel also provides the `pn.io.profile` decorator that can be added to any callback and will report the profiling results in the `/admin` panel. The `profile` helper takes to arguments, the name to record the profiling results under and the profiling `engine` to use.\n",
-    "\n",
-    "```python\n",
-    "@pn.io.profile('clustering', engine='snakeviz')\n",
-    "def get_clustering(event):\n",
-    "    # some expensive calculation\n",
-    "    ...\n",
-    "    \n",
-    "widget.param.watch(my_callback, 'value')\n",
-    "```\n",
-    "\n",
-    "<img src=\"../assets/user_profiling.png\" width=\"80%\"></img>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The user profiling may also be used in an interactive session, e.g. we might decorate a simple callback with the `profile` decorator:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import time\n",
-    "\n",
-    "slider = pn.widgets.FloatSlider(name='Test')\n",
-    "\n",
-    "@pn.depends(slider)\n",
-    "@pn.io.profile('formatting')\n",
-    "def format_value(value):\n",
-    "    time.sleep(1)\n",
-    "    return f'Value: {value+1}'\n",
-    "\n",
-    "pn.Row(slider, format_value)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Then we can request the named profile 'formatting' using the `pn.state.get_profile` function:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pn.state.get_profile('formatting')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Logs\n",
-    "\n",
-    "The Logs page provides a detailed breakdown of the user interaction with the application. Additionally users may also log to this logger using the `pn.state.log` function, e.g. in this example we log the arguments to the clustering function:\n",
-    "\n",
-    "```python\n",
-    "def get_clusters(x, y, n_clusters):\n",
-    "    pn.state.log(f'clustering {x!r} vs {y!r} into {n_clusters} clusters.')\n",
-    "    ...\n",
-    "    return ...\n",
-    "```\n",
-    "\n",
-    "\n",
-    "\n",
-    "<img src=\"../assets/admin_logs.png\" width=\"80%\"></img>\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The logging terminal may also be used interactively, however you have to ensure that the 'terminal' extension is loaded with `pn.extension('terminal')`. If the extension is initialized it can be rendered by accessing it on `pn.state.log_terminal`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "slider = pn.widgets.FloatSlider(name='Test')\n",
-    "\n",
-    "@pn.depends(slider)\n",
-    "def format_value(value):\n",
-    "    pn.state.log(f'formatting value {value}')\n",
-    "    return f'Value: {value+1}'\n",
-    "\n",
-    "pn.Column(\n",
-    "    pn.Row(slider, format_value),\n",
-    "    pn.state.log_terminal,\n",
-    "    sizing_mode='stretch_both'\n",
-    ")\n"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python",
-   "pygments_lexer": "ipython3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

From 1e961b83514562f99c45913458f08174f0155cd3 Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Thu, 5 Jan 2023 15:57:55 +0100
Subject: [PATCH 14/15] Fix linting

---
 doc/api/index.md                           |  2 +-
 doc/how_to/apis/callbacks.md               |  1 +
 doc/how_to/apis/parameterized.md           |  2 +-
 doc/how_to/concurrency/async.md            | 10 +++++-----
 doc/how_to/concurrency/index.md            |  4 ++--
 doc/how_to/concurrency/manual_threading.md |  4 ++--
 doc/how_to/concurrency/processes.md        |  2 +-
 doc/how_to/concurrency/threading.md        |  4 ++--
 doc/how_to/display/editor.md               |  2 +-
 doc/how_to/display/index.md                |  2 +-
 doc/how_to/display/jupyterlab.md           |  2 +-
 doc/how_to/display/notebook.md             |  8 ++++----
 doc/how_to/index.md                        |  6 +++---
 doc/how_to/links/jscallbacks.md            |  2 ++
 doc/how_to/param/dependencies.md           |  1 +
 doc/how_to/param/subobjects.md             |  3 +++
 doc/how_to/performance/index.md            |  2 +-
 doc/how_to/performance/layout.md           |  2 +-
 doc/how_to/performance/throttling.md       |  2 +-
 doc/how_to/profiling/admin.md              |  2 +-
 doc/how_to/profiling/index.md              | 10 +++++-----
 doc/how_to/profiling/logs.md               |  2 +-
 doc/how_to/profiling/profile.md            |  4 ++--
 doc/how_to/state/busy.md                   |  2 ++
 24 files changed, 45 insertions(+), 36 deletions(-)

diff --git a/doc/api/index.md b/doc/api/index.md
index fd9fd85ef2..6e852dda7b 100644
--- a/doc/api/index.md
+++ b/doc/api/index.md
@@ -20,7 +20,7 @@ The Cheat Sheet provides a high-level overview of some of the most important fun
 :link: config
 :link-type: doc
 
-The `panel.config` provides a way to set high-level configuration options. 
+The `panel.config` provides a way to set high-level configuration options.
 :::
 
 :::{grid-item-card} {octicon}`link;2.5em;sd-mr-1` State
diff --git a/doc/how_to/apis/callbacks.md b/doc/how_to/apis/callbacks.md
index e5710ecb21..bec187d2ef 100644
--- a/doc/how_to/apis/callbacks.md
+++ b/doc/how_to/apis/callbacks.md
@@ -19,6 +19,7 @@ In this approach we once again define the widgets. Unlike in other approaches we
 
 ```{pyodide}
 import hvplot.pandas
+import panel as pn
 
 from bokeh.sampledata.autompg import autompg
 
diff --git a/doc/how_to/apis/parameterized.md b/doc/how_to/apis/parameterized.md
index c91b351aaf..db3476ef47 100644
--- a/doc/how_to/apis/parameterized.md
+++ b/doc/how_to/apis/parameterized.md
@@ -37,7 +37,7 @@ class MPGExplorer(param.Parameterized):
 
     @param.depends('x', 'y', 'color') # optional in this case
     def plot(self):
-        return autompg.hvplot.scatter(x, y, c=color, padding=0.1)
+        return autompg.hvplot.scatter(self.x, self.y, c=self.color, padding=0.1)
 
 explorer = MPGExplorer()
 
diff --git a/doc/how_to/concurrency/async.md b/doc/how_to/concurrency/async.md
index 278528a276..f0f0217bd0 100644
--- a/doc/how_to/concurrency/async.md
+++ b/doc/how_to/concurrency/async.md
@@ -12,11 +12,11 @@ async def get_img(index):
     async with aiohttp.ClientSession() as session:
         async with session.get(f"https://picsum.photos/800/300?image={index}") as resp:
             return pn.pane.JPG(await resp.read())
-            
+
 pn.Column(widget, pn.bind(get_img, widget))
 ```
 
-In this example Panel will invoke the function and update the output when the function returns while leaving the process unblocked for the duration of the `aiohttp` request. 
+In this example Panel will invoke the function and update the output when the function returns while leaving the process unblocked for the duration of the `aiohttp` request.
 
 Similarly you can attach asynchronous callbacks using `.param.watch`:
 
@@ -29,11 +29,11 @@ async def update_img(event):
     async with aiohttp.ClientSession() as session:
         async with session.get(f"https://picsum.photos/800/300?image={event.new}") as resp:
             image.object = await resp.read()
-            
+
 widget.param.watch(update_img, 'value')
 widget.param.trigger('value')
-            
+
 pn.Column(widget, image)
 ```
 
-In this example Param will await the asynchronous function and the image will be updated when the request completes.
\ No newline at end of file
+In this example Param will await the asynchronous function and the image will be updated when the request completes.
diff --git a/doc/how_to/concurrency/index.md b/doc/how_to/concurrency/index.md
index ccc3ea2209..49a970e531 100644
--- a/doc/how_to/concurrency/index.md
+++ b/doc/how_to/concurrency/index.md
@@ -4,7 +4,7 @@ When deploying a Panel application to be accessed by multiple users they will of
 
 1. `Load balancing`: A load balancer distributes network traffic between multiple instances of the Panel application. This ensures that the load is distributed across multiple servers but also requires a lot configuration and resources.
 2. `Multi-process server instance`: Launches your app with multiple processes on a single machine. Much simpler to set up than a load balancer but the load is not distributed equally across processes and you are limited by the compute and memory resources on one machine.
-2. `Threading`: Attempts to distribute processing across multiple threads. Effectiveness depends on the operations being performed, I/O bound and CPU bound operations that release the GIL can easily be made concurrent in this way. 
+2. `Threading`: Attempts to distribute processing across multiple threads. Effectiveness depends on the operations being performed, I/O bound and CPU bound operations that release the GIL can easily be made concurrent in this way.
 3. `AsyncIO`: Allows asynchronously processing I/O bound operations. Effective for many concurrent I/O operations but requires rewriting your application and callbacks to make use of `async`/`await` paradigm.
 
 ## Scaling across processes
@@ -71,4 +71,4 @@ load_balancing
 processes
 threading
 async
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/concurrency/manual_threading.md b/doc/how_to/concurrency/manual_threading.md
index d777789543..479107f10e 100644
--- a/doc/how_to/concurrency/manual_threading.md
+++ b/doc/how_to/concurrency/manual_threading.md
@@ -25,7 +25,7 @@ def callback():
         text.value = "Queue empty"
         c.release()
         time.sleep(1)
-        
+
 thread = threading.Thread(target=callback)
 thread.start()
 ```
@@ -41,4 +41,4 @@ button.on_click(on_click)
 pn.Row(button, text).servable()
 ```
 
-Since the processing happens on a separate thread the application itself can still remain responsive to further user input (such as putting new items on the queue).
\ No newline at end of file
+Since the processing happens on a separate thread the application itself can still remain responsive to further user input (such as putting new items on the queue).
diff --git a/doc/how_to/concurrency/processes.md b/doc/how_to/concurrency/processes.md
index 7d27e8c454..3d452b20df 100644
--- a/doc/how_to/concurrency/processes.md
+++ b/doc/how_to/concurrency/processes.md
@@ -2,4 +2,4 @@
 
 Launching a Panel application on multiple processes is effectively a simpler way to scale your application. One major advantage is that it is easy to set up, when deploying your application with `panel serve` simply configure `--num-procs N`, where N is the number of processes. Generally choose an `N` that is no larger than the number of processors on your machine.
 
-The main limitation is that the underlying Tornado multi-process mode does not balance connections across processes. Rather, any incoming connection will be assigned to the first server process that accepts it. Typically any idle process can get a new client regardless of how many clients it already has. In general the resulting distribution of clients across processes will be unequal. Moreover, this still uses significantly more resources since each process has the same overhead and all processes will be contending for the same memory and compute resources. However if your application is single-threaded and you have sufficient memory this is a simple way to make your application scale.
\ No newline at end of file
+The main limitation is that the underlying Tornado multi-process mode does not balance connections across processes. Rather, any incoming connection will be assigned to the first server process that accepts it. Typically any idle process can get a new client regardless of how many clients it already has. In general the resulting distribution of clients across processes will be unequal. Moreover, this still uses significantly more resources since each process has the same overhead and all processes will be contending for the same memory and compute resources. However if your application is single-threaded and you have sufficient memory this is a simple way to make your application scale.
diff --git a/doc/how_to/concurrency/threading.md b/doc/how_to/concurrency/threading.md
index 7aba9cfc03..85c22cfcf8 100644
--- a/doc/how_to/concurrency/threading.md
+++ b/doc/how_to/concurrency/threading.md
@@ -1,6 +1,6 @@
 # Enable Automatic Threading
 
-Using threading in Panel can either be enabled manually, e.g. by managing your own thread pool and dispatching concurrent tasks to it, or it can be managed by Panel itself by setting the `config.nthreads` parameter (or equivalently by setting it with `pn.extension(nthreads=...)`. This will start a `ThreadPoolExecutor` with the specified number of threads (or if set to `0` it will set the number of threads based on your system, i.e. `min(32, os.cpu_count() + 4)`). 
+Using threading in Panel can either be enabled manually, e.g. by managing your own thread pool and dispatching concurrent tasks to it, or it can be managed by Panel itself by setting the `config.nthreads` parameter (or equivalently by setting it with `pn.extension(nthreads=...)`. This will start a `ThreadPoolExecutor` with the specified number of threads (or if set to `0` it will set the number of threads based on your system, i.e. `min(32, os.cpu_count() + 4)`).
 
 Whenever an event is generated or a periodic callback fires Panel will then automatically dispatch the event to the executor. An event in this case refers to any action generated on the frontend such as the manipulation of a widget by a user or the interaction with a plot. If you are launching an application with `panel serve` you should enable this option configure this option on the CLI by setting `--num-threads`.
 
@@ -15,7 +15,7 @@ def button_click(event):
     print('Button clicked for the {event.new}th time.')
     time.sleep(2) # Simulate long running operation
     print('Finished processing {event.new}th click.')
-    
+
 button = pn.widgets.Button(name='Click me!')
 
 button.on_click(button_click)
diff --git a/doc/how_to/display/editor.md b/doc/how_to/display/editor.md
index c7d95fc87a..e06ec0ccea 100644
--- a/doc/how_to/display/editor.md
+++ b/doc/how_to/display/editor.md
@@ -1,3 +1,3 @@
 # Develop Apps in an Editor
 
-WIP
\ No newline at end of file
+WIP
diff --git a/doc/how_to/display/index.md b/doc/how_to/display/index.md
index f42d981a2a..811b0c3ef8 100644
--- a/doc/how_to/display/index.md
+++ b/doc/how_to/display/index.md
@@ -38,4 +38,4 @@ How to use the Preview functionality in JupyterLab to rapidly develop applicatio
 notebook
 editor
 jupyterlab
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/display/jupyterlab.md b/doc/how_to/display/jupyterlab.md
index 9a3df2a205..31fb028174 100644
--- a/doc/how_to/display/jupyterlab.md
+++ b/doc/how_to/display/jupyterlab.md
@@ -1,3 +1,3 @@
 # Develop Apps in JupyterLab
 
-WIP
\ No newline at end of file
+WIP
diff --git a/doc/how_to/display/notebook.md b/doc/how_to/display/notebook.md
index 49600f3496..92ab937639 100644
--- a/doc/how_to/display/notebook.md
+++ b/doc/how_to/display/notebook.md
@@ -20,7 +20,7 @@ pn.extension('vega', 'tabulator')
 
 ## Display output
 
-One of the major benefits of notebook environments is that they support rich output. This means that if you place an object with rich output at the end of a cell the notebook will figure out how to render the rich representation. Panel uses this mechanism to ensure that all components return a rich representation: 
+One of the major benefits of notebook environments is that they support rich output. This means that if you place an object with rich output at the end of a cell the notebook will figure out how to render the rich representation. Panel uses this mechanism to ensure that all components return a rich representation:
 
 ```{pyodide}
 pane = pn.panel('<marquee>Here is some custom HTML</marquee>')
@@ -41,7 +41,7 @@ To avoid having to put a Panel on the last line of a notebook cell, e.g. to disp
 ```{pyodide}
 def display_marquee(text):
     display(pn.panel('<marquee>{text}</marquee>'.format(text=text)))
-    
+
 display_marquee('This Panel was displayed from within a function')
 ```
 
@@ -70,7 +70,7 @@ Accordion(children=[pn.ipywidget(pane)])
 ```
 
 To use Panel's ipywidgets support in JupyterLab, the following extensions have to be installed:
- 
+
 ```
 jupyter labextension install @jupyter-widgets/jupyterlab-manager
 jupyter labextension install @bokeh/jupyter_bokeh
@@ -86,4 +86,4 @@ or using conda:
 
 ```
 conda install -c bokeh jupyter_bokeh
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/index.md b/doc/how_to/index.md
index ecc054dfd7..6793c72aed 100644
--- a/doc/how_to/index.md
+++ b/doc/how_to/index.md
@@ -86,21 +86,21 @@ How to access state related to the user session, HTTP request and URL arguments.
 How to cache data across sessions and memoize the output of functions.
 :::
 
-:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Improve Performance
+:::{grid-item-card} {octicon}`hourglass;2.5em;sd-mr-1` Improve Performance
 :link: concurrency/index
 :link-type: doc
 
 Discover some tips and tricks instructing you on how you can improve the performance of your application.
 :::
 
-:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Improve Scalability
+:::{grid-item-card} {octicon}`duplicate;2.5em;sd-mr-1` Improve Scalability
 :link: concurrency/index
 :link-type: doc
 
 Discover various approaches telling you how to improve the scalability of your Panel application.
 :::
 
-:::{grid-item-card} {octicon}`versions;2.5em;sd-mr-1` Enable Profiling & Debugging
+:::{grid-item-card} {octicon}`meter;2.5em;sd-mr-1` Enable Profiling & Debugging
 :link: profiling/index
 :link-type: doc
 
diff --git a/doc/how_to/links/jscallbacks.md b/doc/how_to/links/jscallbacks.md
index 3dd9609582..e0fc77dc0a 100644
--- a/doc/how_to/links/jscallbacks.md
+++ b/doc/how_to/links/jscallbacks.md
@@ -5,6 +5,8 @@ Sometimes defining a simple link between to objects is not sufficient, e.g. when
 To implement this we define a `jscallback`, which is triggered when the `Button.clicks` property changes and provide a number of `args` allowing us to access the values of the various widgets:
 
 ```{pyodide}
+import panel as pn
+
 value1 =   pn.widgets.Spinner(value=0, width=75)
 operator = pn.widgets.Select(value='*', options=['*', '+'], width=50, align='center')
 value2 =   pn.widgets.Spinner(value=0, width=75)
diff --git a/doc/how_to/param/dependencies.md b/doc/how_to/param/dependencies.md
index bbc9f6d99e..2439b7b0bc 100644
--- a/doc/how_to/param/dependencies.md
+++ b/doc/how_to/param/dependencies.md
@@ -6,6 +6,7 @@ As a straightforward example without any additional dependencies we will write a
 
 ```{pyodide}
 import panel as pn
+import param
 import numpy as np
 
 class Sine(param.Parameterized):
diff --git a/doc/how_to/param/subobjects.md b/doc/how_to/param/subobjects.md
index 3a3a53bab8..5b47da2f6a 100644
--- a/doc/how_to/param/subobjects.md
+++ b/doc/how_to/param/subobjects.md
@@ -3,6 +3,9 @@
 ``Parameterized`` objects often have parameter values which are themselves ``Parameterized`` objects, forming a tree-like structure. Panel allows you to edit not just the main object's parameters but also lets you drill down to the subobject. Let us first define some classes declaring a hierarchy of Shape classes which draw a Bokeh plot of the selected shape:
 
 ```{pyodide}
+import panel
+import param
+
 from bokeh.plotting import figure
 
 class Shape(param.Parameterized):
diff --git a/doc/how_to/performance/index.md b/doc/how_to/performance/index.md
index a008862ef9..704eef996d 100644
--- a/doc/how_to/performance/index.md
+++ b/doc/how_to/performance/index.md
@@ -28,4 +28,4 @@ Discover how to enable throttling to reduce the number of events being processed
 
 layout
 throttling
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/performance/layout.md b/doc/how_to/performance/layout.md
index ecc23ca590..913e82b7e0 100644
--- a/doc/how_to/performance/layout.md
+++ b/doc/how_to/performance/layout.md
@@ -18,4 +18,4 @@ template.main.append(b)
 template.main.append(c)
 ```
 
-Doing this will ensure that the Bokeh.js layout engine considers each component separately and will speed up rendering a lot if `a`, `b` and `c` are deeply nested components.
\ No newline at end of file
+Doing this will ensure that the Bokeh.js layout engine considers each component separately and will speed up rendering a lot if `a`, `b` and `c` are deeply nested components.
diff --git a/doc/how_to/performance/throttling.md b/doc/how_to/performance/throttling.md
index 0dcdb008c2..88dcb45651 100644
--- a/doc/how_to/performance/throttling.md
+++ b/doc/how_to/performance/throttling.md
@@ -11,4 +11,4 @@ def output(value):
 pn.bind(output, slider.param.value_throttled)
 ```
 
-Alternatively you can also ensure that all sliders only update on mouse release if you set `pn.config.throttled = True`.
\ No newline at end of file
+Alternatively you can also ensure that all sliders only update on mouse release if you set `pn.config.throttled = True`.
diff --git a/doc/how_to/profiling/admin.md b/doc/how_to/profiling/admin.md
index ee7809b54e..a93d1de14b 100644
--- a/doc/how_to/profiling/admin.md
+++ b/doc/how_to/profiling/admin.md
@@ -4,4 +4,4 @@ The `/admin` panel provides an overview of the current application and provides
 
 When you have successfully enabled it you should be able to visit the `/admin` endpoint of your application, e.g. if you are serving locally on port 5006, visit `http://localhost:5006/admin`. You should now be greeted with the overview page, which provides some details about currently active sessions, running versions and resource usage (if `psutil` is installed):
 
-<img src="../../_static/admin_overview.png" width="70%"></img>
\ No newline at end of file
+<img src="../../_static/admin_overview.png" width="70%"></img>
diff --git a/doc/how_to/profiling/index.md b/doc/how_to/profiling/index.md
index 3d4b05c6a1..77856bb780 100644
--- a/doc/how_to/profiling/index.md
+++ b/doc/how_to/profiling/index.md
@@ -2,25 +2,25 @@
 
 When trying to understand the performance profiles or track down issues with an application the server logs are rarely sufficient to gain insights. For that reason Panel ships with an admin dashboard that allows tracking resource usage, user behavior, and provides ways of visualizing profiling output to discover bottlenecks in an application.
 
-::::{grid} 1 2 2 2
+::::{grid} 1 2 2 3
 :gutter: 1 1 1 2
 
 :::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Enable the Admin Panel
-:link: load_balancing
+:link: admin
 :link-type: doc
 
 Discover how-to enable the admin Panel to begin monitoring resource usage and user behavior.
 :::
 
 :::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` Profile your Application
-:link: processes
+:link: profile
 :link-type: doc
 
 Discover how to enable profilers like snakeviz or memray to track down bottlenecks in your application.
 :::
 
 :::{grid-item-card} {octicon}`workflow;2.5em;sd-mr-1` View Application Logs
-:link: processes
+:link: logs
 :link-type: doc
 
 Discover how to view application logs in the admin dashboard.
@@ -36,4 +36,4 @@ Discover how to view application logs in the admin dashboard.
 admin
 profile
 logs
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/profiling/logs.md b/doc/how_to/profiling/logs.md
index 7689797ce9..cec266169b 100644
--- a/doc/how_to/profiling/logs.md
+++ b/doc/how_to/profiling/logs.md
@@ -9,4 +9,4 @@ def get_clusters(x, y, n_clusters):
     return ...
 ```
 
-<img src="../../_static/admin_logs.png" width="80%"></img>
\ No newline at end of file
+<img src="../../_static/admin_logs.png" width="80%"></img>
diff --git a/doc/how_to/profiling/profile.md b/doc/how_to/profiling/profile.md
index cadfa760e2..d2f713e7f4 100644
--- a/doc/how_to/profiling/profile.md
+++ b/doc/how_to/profiling/profile.md
@@ -23,7 +23,7 @@ In addition to profiling the launch step of an application it is often also impo
 def get_clustering(event):
     # some expensive calculation
     ...
-    
+
 widget.param.watch(my_callback, 'value')
 ```
 
@@ -49,4 +49,4 @@ Then we can request the named profile 'formatting' using the `pn.state.get_profi
 
 ```python
 pn.state.get_profile('formatting')
-```
\ No newline at end of file
+```
diff --git a/doc/how_to/state/busy.md b/doc/how_to/state/busy.md
index bd9e472b6e..c75da01f75 100644
--- a/doc/how_to/state/busy.md
+++ b/doc/how_to/state/busy.md
@@ -7,6 +7,8 @@ Below we will create a little application to demonstrate this, we will create a
 ```{pyodide}
 import time
 
+import panel as pn
+
 def processing(event):
     # Some longer running task
     time.sleep(1)

From c70431a2a4fb2b8ce5614172298115ba6cf3058a Mon Sep 17 00:00:00 2001
From: Philipp Rudiger <prudiger@anaconda.com>
Date: Thu, 5 Jan 2023 16:54:10 +0100
Subject: [PATCH 15/15] Fix tests

---
 doc/how_to/apis/callbacks.md               | 5 +++--
 doc/how_to/caching/memoization.md          | 2 +-
 doc/how_to/concurrency/manual_threading.md | 2 +-
 doc/how_to/export/bokeh.md                 | 8 ++++++--
 doc/how_to/param/custom.md                 | 2 +-
 doc/how_to/param/subobjects.md             | 3 ++-
 doc/how_to/state/url.md                    | 6 +++---
 panel/tests/test_docs.py                   | 4 ++--
 8 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/doc/how_to/apis/callbacks.md b/doc/how_to/apis/callbacks.md
index bec187d2ef..a8a1578208 100644
--- a/doc/how_to/apis/callbacks.md
+++ b/doc/how_to/apis/callbacks.md
@@ -31,10 +31,11 @@ color = pn.widgets.ColorPicker(name='Color', value='#880588')
 
 layout = pn.Row(
     pn.Column('## MPG Explorer', x, y, color),
-    autompg_plot(x.value, y.value, color.value))
+    autompg.hvplot.scatter(x.value, y.value, c=color.value, padding=0.1)
+)
 
 def update(event):
-    layout[1].object = autompg_plot(x.value, y.value, color.value)
+    layout[1].object = autompg.hvplot.scatter(x.value, y.value, c=color.value, padding=0.1)
 
 x.param.watch(update, 'value')
 y.param.watch(update, 'value')
diff --git a/doc/how_to/caching/memoization.md b/doc/how_to/caching/memoization.md
index 1ba246ccde..3e9fca9fa4 100644
--- a/doc/how_to/caching/memoization.md
+++ b/doc/how_to/caching/memoization.md
@@ -26,7 +26,7 @@ select = pn.widgets.Select(options={
     'Penguins': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv',
     'Diamonds': 'https://raw.githucbusercontent.com/mwaskom/seaborn-data/master/diamonds.csv',
     'Titanic': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv',
-    'MPG': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv'
+    'MPG': 'https://raw.githubusercontent.com/mwaskom/seaborn-data/mastser/mpg.csv'
 })
 
 @pn.cache
diff --git a/doc/how_to/concurrency/manual_threading.md b/doc/how_to/concurrency/manual_threading.md
index 479107f10e..4661fea965 100644
--- a/doc/how_to/concurrency/manual_threading.md
+++ b/doc/how_to/concurrency/manual_threading.md
@@ -19,7 +19,7 @@ def callback():
         c.acquire()
         for i, event in enumerate(queue):
             text.value = f'Processing item {i+1} of {len(queue)} items in queue.'
-	    ... # Do something with the event
+            ... # Do something with the event
             time.sleep(2)
         queue.clear()
         text.value = "Queue empty"
diff --git a/doc/how_to/export/bokeh.md b/doc/how_to/export/bokeh.md
index 8edefaea7e..5d98bbfc63 100644
--- a/doc/how_to/export/bokeh.md
+++ b/doc/how_to/export/bokeh.md
@@ -2,16 +2,20 @@
 
 Since Panel is built on top of Bokeh, all Panel objects can easily be converted to a Bokeh model. The ``get_root`` method returns a model representing the contents of a Panel:
 
-```python
+```{pyodide}
+import panel as pn
+
 model = pn.Column('# Some markdown').get_root()
 model
 ```
 
 By default this model will be associated with Bokeh's ``curdoc()``, so if you want to associate the model with some other ``Document`` ensure you supply it explictly as the first argument. Once you have access to the underlying bokeh model you can use all the usual bokeh utilities such as ``components``, ``file_html``, or ``show``
 
-```python
+```{pyodide}
 from bokeh.embed import components, file_html
 from bokeh.io import show
 
 script, html = components(model)
+
+print(html)
 ```
diff --git a/doc/how_to/param/custom.md b/doc/how_to/param/custom.md
index 5ee192e231..20873eded3 100644
--- a/doc/how_to/param/custom.md
+++ b/doc/how_to/param/custom.md
@@ -39,7 +39,7 @@ However it is also possible to explicitly construct a widget from a parameter us
 
 
 ```{pyodide}
-pn.widgets.IntSlider.from_param(Example.param.unbounded_int, start=0, end=100)
+pn.widgets.RadioBoxGroup.from_param(CustomExample.param.select_string, inline=True)
 ```
 
 ## Custom name
diff --git a/doc/how_to/param/subobjects.md b/doc/how_to/param/subobjects.md
index 5b47da2f6a..b9775d5375 100644
--- a/doc/how_to/param/subobjects.md
+++ b/doc/how_to/param/subobjects.md
@@ -3,7 +3,8 @@
 ``Parameterized`` objects often have parameter values which are themselves ``Parameterized`` objects, forming a tree-like structure. Panel allows you to edit not just the main object's parameters but also lets you drill down to the subobject. Let us first define some classes declaring a hierarchy of Shape classes which draw a Bokeh plot of the selected shape:
 
 ```{pyodide}
-import panel
+import numpy as np
+import panel as pn
 import param
 
 from bokeh.plotting import figure
diff --git a/doc/how_to/state/url.md b/doc/how_to/state/url.md
index e8e7b351fc..86637d1de5 100644
--- a/doc/how_to/state/url.md
+++ b/doc/how_to/state/url.md
@@ -29,7 +29,7 @@ By default the current [query parameters](https://en.wikipedia.org/wiki/Query_st
 
 We will start by defining a `Parameterized` class:
 
-```{pyodide}
+```python
 import param
 import panel as pn
 
@@ -42,13 +42,13 @@ class QueryExample(param.Parameterized):
 
 Now we will use the `pn.state.location` object to sync it with the URL query string (note that in a notebook environment `pn.state.location` is not initialized until the first plot has been displayed). The sync method takes the Parameterized object or instance to sync with as the first argument and a list or dictionary of the parameters as the second argument. If a dictionary is provided it should map from the Parameterized object's parameters to the query parameter name in the URL:
 
-```{pyodide}
+```python
 pn.state.location.sync(QueryExample, {'integer': 'int', 'string': 'str'})
 ```
 
 Now the Parameterized object is bi-directionally linked to the URL query parameter, if we set a query parameter in Python it will update the URL bar and when we specify a URL with a query parameter that will be set on the Parameterized, e.g. let us set the 'integer' parameter and watch the URL in your browser update:
 
-```{pyodide}
+```python
 QueryExample.integer = 5
 ```
 
diff --git a/panel/tests/test_docs.py b/panel/tests/test_docs.py
index 3cf0aac47a..ff94453fe9 100644
--- a/panel/tests/test_docs.py
+++ b/panel/tests/test_docs.py
@@ -75,13 +75,13 @@ def is_panel_pane(attr):
 def test_markdown_codeblocks(file, tmp_path):
     from markdown_it import MarkdownIt
 
-    exceptions = ("await", "pn.serve", "django")
+    exceptions = ("await", "pn.serve", "django", "raise", "display(")
 
     md_ast = MarkdownIt().parse(file.read_text(encoding="utf-8"))
     lines = ""
     for n in md_ast:
         if n.tag == "code" and n.info is not None:
-            if "pyodide" in n.info.lower() or "python" in n.info.lower():
+            if "pyodide" in n.info.lower():
                 if ">>>" not in n.content:
                     lines += n.content
     if not lines: