Run a worker on Windows.

A Windows PC runs the same worker image as a Linux box. Docker Desktop runs a Linux machine through WSL2, the worker container runs inside it, and from there the host is x86_64 Linux with whatever GPU the Windows driver exposes.

There is no Windows container build. Do not port the worker and do not run the Linux image as a Windows container. WSL2 is the supported shape, because the CUDA path you want is the Linux one.

What you need.

Windows
Windows 11, or Windows 10 21H2 or later.
WSL2
An Ubuntu distro on WSL2, x86_64. Windows on ARM laptops are not supported in this release, for the same reason bare-metal ARM is not.
Docker Desktop
Installed, with the WSL2 backend and WSL integration enabled for the distro you will use.
Driver, for a GPU
The current NVIDIA driver installed on the Windows side. That driver is what gives CUDA to WSL2. Do not install a Linux NVIDIA driver inside WSL: it is the most common way this setup breaks. A CPU worker needs none of this.
Disk
20 GB or more for the model cache. It lives on the WSL virtual disk, which grows to fit and does not hand space back to Windows on its own, so leave headroom rather than planning to reclaim it later.

Set it up.

1. Install WSL2 and Ubuntu

From an elevated PowerShell:

wsl --install -d Ubuntu

Reboot if it asks, then finish the Ubuntu first run and set a username and password.

2. Install Docker Desktop

Then enable two settings:

General   -> Use the WSL 2 based engine
Resources -> WSL Integration -> your Ubuntu distro

3. Check the three things that have to be true

Everything from here on runs inside Ubuntu, not PowerShell and not cmd.exe. Open Ubuntu from the Start menu, or run wsl, and confirm:

uname -m                       # x86_64
nvidia-smi                     # your GPU, seen through the Windows driver
docker run --rm hello-world    # Docker Desktop is reachable from WSL

On a CPU worker nvidia-smi is expected to fail. The other two are not.

Install the worker.

With an NVIDIA GPU:

sudo apt-get update && sudo apt-get install -y curl jq

mkdir -p ~/autarcho-worker && cd ~/autarcho-worker
curl -fsSLO https://autarcho.com/workers/docker-compose.yml
curl -fsSLO https://autarcho.com/workers/docker-compose.gpu.yml
curl -fsSLO https://autarcho.com/workers/install.sh
chmod +x install.sh

./install.sh --wallet <SOLANA_PUBKEY> --gpu --compute-cap <NN>
docker compose -f docker-compose.yml -f docker-compose.gpu.yml pull
docker compose -f docker-compose.yml -f docker-compose.gpu.yml up -d
docker compose -f docker-compose.yml -f docker-compose.gpu.yml logs -f node

<NN> is the compute capability without the dot. nvidia-smi --query-gpu=compute_cap --format=csv,noheader prints 8.6, so you pass 86.

Without a GPU, drop --gpu --compute-cap <NN> and both -f overrides, and use the CPU quickstart on the worker page unchanged.

Check that the GPU reached the container.

WSL2 seeing the GPU does not mean the container was given it, and a worker that fell back to the CPU still serves, just far slower. The worker names the device it can see:

docker compose -f docker-compose.yml -f docker-compose.gpu.yml logs node \
  | grep -i gpu_name

A line naming your card means the GPU path is live. Nothing matching means the container has no accelerated device: check that both -f files are passed on every command and that WORKER_CUDA_COMPUTE_CAP is set in .env.

Keep it running.

Docker Desktop has to stay running, because the worker lives inside its machine. Turn on Start Docker Desktop when you sign in. A sleeping Windows host stops the machine and the worker leaves the network until it wakes.

powercfg /change standby-timeout-ac 0

WSL2 gives its machine about half the host's memory by default, while the compose file caps the container at 16 GB. On a 32 GB machine that leaves the worker pressed against its own limit. Set the share deliberately in %UserProfile%\.wslconfig, then restart WSL with wsl --shutdown:

[wsl2]
memory=24GB

Keep WORKER_MAX_MEMORY_BYTES at or below about 75% of WORKER_MEM_LIMIT, as on Linux.

Back up the worker identity exactly as you would on Linux. It lives in the worker-data volume, and losing it changes the worker's identity on the network. The recipe is in the full operator guide.

When it does not work.

nvidia-smi fails inside Ubuntu
Either the Windows driver is too old for WSL GPU support, in which case update it on the Windows side, or the distro is not on WSL2. wsl -l -v shows the version.
docker is not found inside Ubuntu
Docker Desktop is not running, or WSL integration is off for this distro. Check Settings, Resources, WSL Integration.
The container runs but stays on the CPU
Pass both compose files on every pull, up and logs, and set WORKER_CUDA_COMPUTE_CAP in .env. The image tag carries the capability and compose will not start without it. install.sh --gpu --compute-cap NN writes that value for you.
Everything is slow and the container sits at its memory limit
The WSL machine, not the worker, is the constraint. Raise the share in .wslconfig as above.

What is not supported.

A native Windows build of the worker. There is no Windows binary, and a Linux container is the supported shape. Everything on this page is how Windows runs it.

Windows on ARM. The worker images are x86_64, and a Snapdragon laptop cannot run them with GPU acceleration. Neither bare-metal ARM nor Windows on ARM is supported in this release.

Windows containers. The image is a Linux image and WSL2 is where it runs.