Palworld Server in Docker: Official Setup and Updates

If you already run Docker, it can make a Palworld server easier to replace and keep its files in one visible folder. Start with Pocketpair’s official image and Compose sample so the container, saved world, and game port match the current project. This walkthrough covers a native 64-bit Linux host, the generated settings file, and a backup-first update. Docker Desktop on Windows and macOS is discouraged by Pocketpair because its storage path can put saved data at risk. A container starting is only the first check; you still need to test a real connection from outside the host.

Choose a Linux host that fits Pocketpair’s Docker warning#

Docker is a reasonable route if you are comfortable maintaining the Linux machine underneath it. You still own its operating system, storage, network rules, and backups. For this recipe, use Docker Engine with the Compose plugin on a 64-bit Linux host. Pocketpair’s current requirements recommend 16 GB of memory. Its documentation says 8 GB can boot, with a greater chance of an out-of-memory crash; booting is not a stability guarantee.

Pocketpair discourages Docker Desktop on Windows and macOS because disk I/O limitations can increase the risk of save corruption or malfunction. Treat that as a reason to choose native Linux for a persistent world, not as proof that every Desktop installation will lose data. If Linux administration is not part of your plan, the Palworld dedicated-server overview compares Docker with the other ways to run a server.

Do not infer official ARM or NAS support from Docker itself. Check the image’s published architectures against the exact machine before investing time in an unsupported target.

Start Pocketpair’s official Compose sample#

The official repository includes the image, helper script, and Compose configuration that work together. Clone the current repository, enter its Compose folder, and check the file before starting it:

git clone --depth 1 https://github.com/pocketpairjp/palworld-dedicated-server-docker.git
cd palworld-dedicated-server-docker/compose
docker compose config

docker compose config should print a resolved service without an error. The sample currently uses image repository ghcr.io/pocketpairjp/palserver with tag v1.0.5.102999; check Pocketpair’s repository for the current tag before using it, since game and image versions change. Start the service from that same compose directory:

docker compose up -d
docker compose ps
docker compose logs --tail=50

The official sample includes older performance flags in its command. Pocketpair’s current argument documentation says leaving those flags unset may improve performance in v1.0 and later. Remove -useperfthreads, -NoAsyncLoadingThread, and -UseMultithreadForDS from the sample rather than treating them as required tuning. Keep its helper entrypoint and intended -port value intact.

Look for the game version and a line indicating that the dedicated server is running. A container marked Up without those application logs may still be initializing or failing. These checks prove that the process booted; they do not prove that another player can reach it.

Keep the world in the host-side Saved folder#

The official Compose file binds the Saved directory beside the Compose file into /pal/Package/Pal/Saved inside the container. That bind mount keeps the server’s saved data in a host-visible directory when the container is replaced. Docker documents that bind mounts connect a host path to a container path; confirm the exact ./Saved mapping in the official file before changing it.

After the first start, check for the generated configuration on the host: PalWorldSettings.ini inside Saved/Config/LinuxServer/.

Edit that file to change supported Palworld server settings. Do not edit DefaultPalWorldSettings.ini as a substitute: Pocketpair documents the generated Linux server settings path. Settings and environment variables from community images are image-specific and do not automatically apply to Pocketpair’s image.

docker compose down
test -f Saved/Config/LinuxServer/PalWorldSettings.ini && echo "settings file found"

If that check fails, verify that you ran the command from the compose folder and that the bind mount still points to ./Saved. Before replacing or moving the folder, make a separate copy; a bind mount helps retain files but is not itself a backup.

Publish the game’s UDP port deliberately#

Pocketpair’s sample maps 8211:8211/udp. UDP 8211 is the default game connection port in Pocketpair’s server requirements. For this image, that single mapping is the documented starting point; do not add UDP 27015 just because an older community-image tutorial includes it.

If you change -port, update the container-side port and external firewall/router rules to match. Docker publishing alone does not configure a home router or cloud firewall. Use the address visible to your players, then test from a separate network or player connection; a local check from the host cannot prove the route from the internet.

Change settings in the generated Linux server file#

Start the official container once so it creates its Saved tree. Then open PalWorldSettings.ini inside the host folder Saved/Config/LinuxServer/ with an editor, change only keys supported by the current Palworld configuration reference, and save the file. In the container, the same file sits inside Config/LinuxServer/ below the Saved folder under /pal/Package/Pal/; the relative host path is usually easier to back up and inspect.

Do not paste a SERVER_NAME, SERVER_PASSWORD, or similar environment-variable example from a different image into this Compose file and assume it will work. Pocketpair’s sample uses its own helper and persisted INI path. If the file is missing, read the container logs first and confirm the host mapping before creating a hand-written replacement. For a broader explanation of the settings themselves, use the Palworld server settings guide; this Docker walkthrough only establishes where this image stores them.

After a supported edit, restart the service and inspect the logs again:

docker compose restart
docker compose logs --tail=50

The logs should return to a running state. That check does not prove that each setting has the intended in-game effect, so verify important changes with a player before relying on them.

Check startup, then test a player connection separately#

Use the log and network checks for different questions. First confirm the application started; then make sure the advertised address and port are the ones a player can reach. Pocketpair’s connection guide describes entering an address and port in the game’s server browser for a direct connection.

1. Confirm the server process is running

   docker compose ps
   docker compose logs --tail=50

   The service should be Up, and the logs should show the game version and that the server is running. If it restarts repeatedly, inspect the first error near the beginning of the logs and check memory and storage before changing settings at random.

2. Check the outside network path

   Confirm that UDP 8211 (or your deliberate replacement port) is published in Compose, allowed by the host and provider firewalls, and forwarded by the router if the host is at home. Give players the reachable public address and port, not a container-only address.

3. Try from a separate player connection

   Use the in-game direct connection flow in Pocketpair’s server connection instructions. Test from a player device on a different network when possible. If it fails, check the address, port, firewall, router forwarding, and compatible game/server versions one layer at a time.

A container’s Up status and a successful docker compose ps are not a multiplayer test. This guide does not claim that a player joined its test instance; verify your own outside connection before inviting the group.

Back up Saved before changing the image tag#

Keep a dated copy of the complete host-side Saved directory somewhere outside the Compose project before updating. Stop the server cleanly first so it is not writing to the world while you copy it:

docker compose down
backup="../backups/Saved-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$(dirname "$backup")"
cp -a Saved "$backup"
test -d "$backup" && echo "backup folder created"

Check that the copied directory contains the expected files and has enough space. The example stores the copy on the same machine; for better protection against host or disk failure, copy it to separate storage as well. Creating a directory is not proof that a complete restore will work, so keep the original until you have verified the backup contents and later checked the world after an update.

To update, change the image tag in Pocketpair’s Compose file to the official version you intend to run, then recreate the service:

docker compose pull
docker compose up -d
docker compose ps
docker compose logs --tail=50

Wait for the expected game version and running message. Keep the dated copy until a player has checked the intended world. This is a backup-first update procedure, not a tested restore recipe; if recovery is required, use a separate copy of the save and verify that procedure before replacing the only original.

Know when a managed server is easier to maintain#

Docker suits a group that already wants to operate Linux, Compose, network rules, and off-host backups. If that maintenance is the part you want to avoid, Game Hosting’s Palworld plans put settings and restarts in an integrated panel and include three free backup slots. A hosted server also avoids forwarding a port on your home router. Those conveniences do not remove the need to check your world or choose a size for your group; Pocketpair recommends 16 GB of memory for a dedicated server.

Sources

• Pocketpair’s official Palworld dedicated-server Docker repository and current Compose sample
• Pocketpair server requirements, configuration guide, server arguments, and connection guide
• Docker documentation for bind mounts and published ports