> ## Documentation Index
> Fetch the complete documentation index at: https://ayakaleaf-pro.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 6. Post-installation tasks

> Create the administrator, verify sandboxed compiles and persistence, and keep Ayakaleaf Pro running on Windows.

### Create the administrator and a first project

Open [http://localhost:8080/launchpad](http://localhost:8080/launchpad) in your **Windows browser**, create the first administrator account and log in. Then follow [6. Post-installation tasks](https://ayakaleaf-pro.mintlify.site/on-premises/installation/using-docker-compose/linux/6.-post-installation-tasks.md) of the Linux guide, using port `8080` in its example URLs.

### Verify compilation

A working login page does not prove that the separate compiler containers can access the WSL data directory. Create a blank project and compile this `main.tex` with **pdfLaTeX**:

```latex theme={null}
\documentclass{article}
\begin{document}
Ayakaleaf Pro on Windows WSL 2.
\end{document}
```

The PDF preview should show the text. For the basic image, select **TeX Live 2026 Basic** in project settings if needed.

Select **XeLaTeX** and test:

```latex theme={null}
\documentclass{article}
\usepackage{fontspec}
\begin{document}
Ayakaleaf WSL XeLaTeX sandbox.
\end{document}
```

Both examples work with basic. For Chinese documents, use an image containing `ctex` and the required fonts, such as full, before testing the following with **XeLaTeX**. Basic does not include them:

```latex theme={null}
\documentclass{ctexart}
\begin{document}
你好，Ayakaleaf Pro。
\end{document}
```

To confirm sandbox use, run in **Ubuntu** while compiling:

```bash theme={null}
docker ps -a --filter ancestor=ghcr.io/ayaka-notes/texlive-basic:2026.1
bin/logs -f clsi
```

Use your chosen image name in the filter. Short compiles may finish before `docker ps` runs; `-a` also shows stopped containers until cleanup. A compiler container should use that image and a `/compile` bind mount from the Toolkit's WSL data directory. Application logs alone are not a substitute for checking the PDF.

### Verify persistence

In **Ubuntu**, from the Toolkit directory:

```bash theme={null}
bin/stop
bin/start
```

Wait for the application, reopen the project from Windows and compile again. Your account, source and project files should still be there. The default live data is in `~/ayakaleaf-toolkit/data/` inside Ubuntu. Keep both `config/` and `data/`; uninstalling or unregistering the Ubuntu distribution can delete them.

### Keep the instance available

There are three parts to keeping the instance running: Windows stays awake, Docker Desktop runs, and the containers restart with the engine.

In Docker Desktop **Settings → General**, turn on **Start Docker Desktop when you sign in to your computer**, see [Docker Desktop settings](https://docs.docker.com/desktop/settings-and-maintenance/settings/). This starts Docker after login, not before login. After a Windows restart, sign in, wait for Docker Desktop to finish starting, open Ubuntu and check `docker ps` and the site.

Docker Desktop's **Resource Saver** is separate from Windows sleep. It normally activates only when no containers are running; the running application, MongoDB and Redis prevent that idle condition. On WSL 2 it pauses the Docker engine rather than shutting down the shared WSL VM. Do not manually **Pause** Docker Desktop while serving users. You do not need to disable Resource Saver merely to keep this stack running; see [Docker's Resource Saver documentation](https://docs.docker.com/desktop/use-desktop/resource-saver/).

The Toolkit services use `restart: always`. Verify the actual setting in **Ubuntu**:

```bash theme={null}
docker inspect sharelatex mongo redis --format '{{.Name}} restart={{.HostConfig.RestartPolicy.Name}}'
```

Each service should report `always`. Once Docker runs, it can restart those existing containers without a new `bin/up`. A manually stopped container stays stopped until you start it or restart the engine; with `always`, an engine restart can start it again. See [Docker's restart policy behavior](https://docs.docker.com/engine/containers/start-containers-automatically/).

| Action | Effect on Ayakaleaf |
| - | - |
| Close the Ubuntu terminal after `bin/up -d` | Containers run detached; the terminal is not their supervisor. Keep Docker Desktop and the WSL environment available |
| Close the Docker Dashboard window | The window can close while Docker Desktop continues in the system tray |
| Choose **Quit Docker Desktop** | Stops the engine and makes the site unavailable; open Docker Desktop again to recover |
| Run `wsl --shutdown` | Stops all WSL distributions and interrupts the Docker WSL backend; restart Docker Desktop and reopen Ubuntu |
| Sleep, hibernate or shut down Windows | The service is unavailable; keeping only the screen on or off does not change this |
| Run `bin/stop` | Stops the instance while retaining its data; use `bin/start` to resume |

For long-running use on AC power, open Windows 11 **Settings → System → Power & battery → Screen, sleep & hibernate timeouts** (some versions show **Power** or **Screen and sleep**). Set the plugged-in sleep timeout to **Never** and disable automatic hibernation if configured. The display can still turn off. A laptop's lid action is a separate setting; closing the lid can put it to sleep even with an idle sleep timeout of Never. See [Windows power settings](https://support.microsoft.com/en-us/windows/experience/power-battery/power-settings-in-windows-11).

Do not run `wsl --shutdown` as routine cleanup while the site is in use. If a WSL settings change needs it, stop the instance first and plan an interruption. Windows can run the instance continuously with these settings. For a shared service that must survive logouts and unattended reboots, we recommend the [Linux guide](https://ayakaleaf-pro.mintlify.site/on-premises/installation/using-docker-compose/linux).

### Check recovery after restarting Docker Desktop

After saving work and allowing active compiles to finish, choose **Restart Docker Desktop** from Docker Desktop's troubleshooting menu. Wait for the engine, then check in **Ubuntu**:

```bash theme={null}
docker ps
curl -I http://localhost:8080/launchpad
```

Open the existing project in Windows and compile it again. Confirm the account and source still exist.

If you intentionally stopped the instance with `bin/stop`, use `bin/start`. If Docker is up but a service fails, read its logs rather than recreating the configuration. Windows Update, Docker updates and power loss can still interrupt a 24-hour installation; keep backups and check recovery after planned maintenance.

### Daily use

Start Docker Desktop in Windows. Open **Ubuntu**:

```bash theme={null}
cd "$HOME/ayakaleaf-toolkit"
```

| Task | Command |
| - | - |
| Start existing containers | `bin/start` |
| Stop containers and keep data | `bin/stop` |
| Apply configuration changes | `bin/up -d` |
| Check status | `bin/docker-compose ps` |
| Read startup logs | `bin/docker-compose logs --tail=100 sharelatex` |
| Read MongoDB logs | `bin/docker-compose logs --tail=100 mongo` |
| Read compiler logs | `bin/logs -f clsi` |

`bin/start` does not apply configuration edits: use `bin/up -d` after changing `config/`. Follow [Data and backups](https://ayakaleaf-pro.mintlify.site/on-premises/maintenance/data-and-backups) before upgrading, moving or removing the WSL distribution. Copying live MongoDB files while the database is writing is not a consistent backup.

Keep `127.0.0.1` for local use. Serving other computers also requires an intentional listen address, site URL, Windows firewall/network configuration and HTTPS; changing `OVERLEAF_SITE_URL` alone does not publish a port.

If something does not work, see [Troubleshooting](https://ayakaleaf-pro.mintlify.site/on-premises/installation/using-docker-compose/windows/troubleshooting.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.