Hosting Cross-Platform Path of Titans via Docker Compose

Path of Titans is one of the few survival titles with true crossplay: PC, mobile, and console clients all share the same lobby, but only if the dedicated server is registered against the Alderon Games backend with a valid API token. The official server binary runs cleanly inside a Linux container, and Docker Compose is the cleanest way to deploy it on Ubuntu 24.04. This guide containerizes the server, mounts the world save outside the image, and wires the Alderon API key so console players can actually join.

Prerequisites

• Ubuntu 24.04 with Docker Engine and the Compose plugin.
• An Alderon Games developer account, plus a generated server API token.
• 8 GB RAM, 4 vCPU, 25 GB disk.
• UDP 7777, UDP 27015, and TCP 7777 open at the firewall.

Step 1: Project Layout

$sudo mkdir -p /opt/pot/{server,save}
$sudo chown -R 1000:1000 /opt/pot
$cd /opt/pot

Step 2: The Compose File

$services:
$  pathoftitans:
$    image: jammsen/path-of-titans-dedicated-server:latest
$    container_name: pathoftitans
$    restart: unless-stopped
$    stop_grace_period: 60s
$    ports:
$      - "7777:7777/udp"
$      - "7777:7777/tcp"
$      - "27015:27015/udp"
$    environment:
$      ALDERON_API_KEY: "REPLACE_WITH_TOKEN"
$      SERVER_NAME: "Vardoran Saurians"
$      SERVER_MAP: "Panjura"
$      SERVER_MAX_PLAYERS: 50
$      GAME_PORT: 7777
$      QUERY_PORT: 27015
$      ENABLE_CROSSPLAY: "true"
$    volumes:
$      - ./server:/home/pot/server
$      - ./save:/home/pot/server/PathOfTitans/Saved

Step 3: First Boot

$docker compose up -d
$docker compose logs -f pathoftitans
$# Look for: "Alderon backend handshake: OK" and "Server registered with crossplay"

Step 4: Tune the Game.ini

After the first boot, the container writes the standard Unreal config tree under ./save/Config/LinuxServer/Game.ini. Drop in a tuned profile that matches a crossplay PvE community.

$[/Script/PathOfTitans.IGameSession]
$ServerName=Vardoran Saurians
$ServerPassword=
$MaxPlayers=50
$ServerType=PvE
$EnableCrossplay=True
$EnableEventServer=False
$
$[/Script/PathOfTitans.IGameInstance]
$RestrictCarnivoreGrouping=True
$AllowMap=Panjura
$AllowMap=Gondwa
$AnnounceServerRestarts=True
$RestartIntervalHours=6

Step 5: Verify Crossplay End to End

On the Alderon developer dashboard, open the server entry and confirm the heartbeat timestamp updates every minute. Then have a console tester search the public browser, the server should appear with the platform agnostic badge.

$# Sanity check that the API key was loaded
$docker compose exec pathoftitans env | grep ALDERON_API_KEY | sed 's/=.*/=[redacted]/'

Step 6: Save Backups

$mkdir -p /opt/pot/backups
$cat <<'EOF' > /opt/pot/backup.sh
$#!/usr/bin/env bash
$set -euo pipefail
$TS=$(date +%Y%m%d-%H%M)
$tar -C /opt/pot -czf /opt/pot/backups/save-${TS}.tar.gz save
$find /opt/pot/backups -type f -mtime +14 -delete
$EOF
$chmod +x /opt/pot/backup.sh
$crontab -e
$0 */6 * * * /opt/pot/backup.sh

Performance and Tuning

• Keep MaxPlayers at 50 or below on a 4 vCPU host, the Unreal authority tick spikes past that.
• Pin the image to a numbered tag in production. The crossplay handshake protocol shifts with Alderon updates.
• Restart the server every 6 hours, the actor pool fragments badly in long sessions.

Conclusion

Docker Compose plus a valid Alderon API token gives you a true crossplay Path of Titans server in one file. The save data lives on the host, the API key is the only secret, and the same compose stack moves to any Docker capable Linux host without modification.