Formerly ARK Server Manager — it outgrew the name. Old repo links redirect.

Now on Unraid Community Applications — search "Palisade" in the Apps tab.

A self-hosted, Docker-based control panel for game dedicated servers — built Unraid-first, but it runs on any Linux box with Docker. One lean manager container spawns and supervises a container per game server, manages every setting through schema-driven forms, and handles mods, backups, schedules, player administration, and even your router's port-forwards.

1. Apps tab → search "Palisade" → Install. The defaults are ready to go — the only field to check is App data: point it at a folder on a real disk (/mnt/cache/appdata/palisade), not the /mnt/user FUSE share, so the game-file cache can reflink-clone between servers.
2. Leave the secrets and HOST_DATA_DIR blank. The manager generates and persists its own keys on first start and auto-detects the host data path — there's nothing to generate in a terminal.
3. Open the WebUI, create your admin account on the first-run screen, and add a game server. That's it.

Not on Unraid? It's a single container — run the same image (ghcr.io/shakes63/palisade) with /var/run/docker.sock and a data volume mounted; see the template in unraid/palisade.xml for the full env/mount list.

Supported games (24):

Feature highlights

• Create → install → start with per-game readiness detection, graceful shutdown, a crash watchdog, and a RAM guard that offers to back up + swap servers when memory is tight.
• Full per-game settings catalogs with presets, copy-between-servers, and restart-needed tracking.
• Live player counts for every game (A2S / RakNet ping / RCON / Valheim status endpoint) with 1-hour sparklines, plus a Players roster captured from player lists and join logs — kick / ban / whitelist / admin per game.
• Backups: manual + scheduled with retention, restore, browser download, and saves import. The manager also snapshots its own database nightly.
• Schedules (restart / update / backup / stop / start) with in-game countdown warnings, pre-action snapshots, and a "skip while players are online" guard.
• ARK cluster support (shared transfer dir across servers).
• Discord/webhook notifications, host low-disk warnings, editable ports with a start-time port-conflict guard.
• Optional pfSense integration: one-click WAN port-forward create/fix/enable/disable/delete per server via the pfSense REST API.

See PLANNING.md for architecture details.

palisade (this app) ────/var/run/docker.sock──> Docker daemon
   Next.js UI + NestJS API                       │ spawns
   SQLite · config engine · RCON · scheduler     ▼
                                       one container per game server

The manager is a control plane only — it contains no game runtime. Each game server runs in its own container from a proven community image; the manager injects config, watches logs, and talks RCON/telnet/query protocols.

• Docker on a Linux host (Unraid, Debian/Ubuntu, etc.). 16 GB+ RAM recommended — a single populated game server wants 2–16 GB depending on the game.

• A Docker bridge network for the manager (game containers join it too unless you use host networking):

  docker network create ark-net

• Two secrets (generate once, keep safe — SECRETS_KEY encrypts stored API keys/passwords, so losing it means re-entering them):

  echo "SECRETS_KEY=$(openssl rand -hex 32)"
  echo "JWT_SECRET=$(openssl rand -hex 32)"

• For the Wine/Proton games (Icarus, Enshrouded, V Rising, Sons of the Forest, LiF:YO), the host needs a larger mmap limit or the server crashes on boot:

  sysctl -w vm.max_map_count=262144
  # persist it: /etc/sysctl.conf, or on Unraid append to /boot/config/go

Palisade is in Community Applications: open the Apps tab, search for Palisade, and install. The template pre-fills everything except your two secrets (SECRETS_KEY, JWT_SECRET — generators above) and the app-data path. The prerequisites above still apply: create the ark-net network and set the vm.max_map_count sysctl once.

Two Unraid-specific notes baked into the template:

• Use a path on the cache disk itself (/mnt/cache/appdata/...), not /mnt/user/... — the ARK game-file cache reflink-clones between servers, which needs one real filesystem.
• Spawned game servers appear on the Docker page with per-game icons and WebUI buttons that deep-link back into Palisade.

(Manual alternative: drop unraid/palisade.xml into /boot/config/plugins/dockerMan/templates-user/.)

docker run -d \
  --name palisade \
  --network ark-net \
  --restart unless-stopped \
  -p 8970:3000 \
  -v /opt/palisade:/data \
  -v /var/run/docker.sock:/var/run/docker.sock \
  --add-host host.docker.internal:host-gateway \
  -e NODE_ENV=production \
  -e DATA_DIR=/data \
  -e DATABASE_URL=file:/data/db.sqlite \
  -e HOST_DATA_DIR=/opt/palisade \
  -e PUBLIC_BASE_URL=http://YOUR-LAN-IP:8970 \
  -e SECRETS_KEY=<64 hex chars> \
  -e JWT_SECRET=<random string> \
  -e PUID=99 -e PGID=100 \
  -e TZ=America/Chicago \
  -e GAME_HOST_NETWORK=true \
  ghcr.io/shakes63/palisade:latest

Then open http://YOUR-LAN-IP:8970 and complete the first-run wizard (create the admin account; API keys are optional and can be added later in Settings).

A reference docker-compose.yml ships in the repo:

export SECRETS_KEY=... JWT_SECRET=... HOST_DATA_DIR=/opt/palisade
docker compose up -d

¹ Required whenever the container path and host path differ — i.e. basically always in production.

Everything lives under your data dir — one directory to back up:

/data
├── db.sqlite            # server definitions, schedules, players, settings
├── instances/<id>/      # each server's game files + world saves
├── backups/<id>/        # world snapshots (retention-rotated)
├── backups/_manager/    # nightly self-backups of db.sqlite (newest 14)
└── clusters/<id>/       # ARK cluster transfer dirs

Deleting a server from the UI asks whether to wipe its instance + backups, and offers a browser download of the world saves first.

Releases are versioned: every vX.Y.Z tag builds and publishes ghcr.io/shakes63/palisade:latest plus matching vX.Y.Z / vX.Y tags (see Releases for changelogs). To update: pull the new image and recreate the container (Unraid's update button does both). Database migrations run automatically on boot. Prefer a fixed version over latest? Point the template at a specific vX.Y.Z tag — any published release remains pullable as a rollback pin.

Channels:

nightly is a prerelease of unreleased main code (versioned like 1.3.2-nightly.202607110245) — expect rough edges, and note it may apply DB migrations a later rollback to a stable release can't undo (Prisma migrates forward only), so back up first. It never moves latest, so stable users can't see it. Opting in and out is just which tag your container tracks: point the image at ghcr.io/shakes63/palisade:nightly to ride prereleases, and back at :latest to rejoin stable at the next release.

CurseForge terms: the mod browser uses the CurseForge API read-only to search and display mods; it never downloads or redistributes mod files — the game servers fetch mods themselves through official integrations. Bring your own key; keys are non-transferable under CurseForge's 3rd-party API terms. This repo does not ship one.

The app is LAN-first but proxy-friendly:

• Front it with Nginx Proxy Manager / Traefik / Caddy with TLS; proxy /, /api, and /socket.io to the web port (container port 3000) — the web app forwards API + websocket traffic internally.
• Set PUBLIC_BASE_URL to the external origin.
• The manager controls Docker via the host socket. If you expose the UI beyond your LAN, strongly consider the socket-proxy setup above.

What's built in:

• Auth: single-admin JWT auth (bcrypt cost 12), 7-day tokens carrying a version claim checked against the DB on every request — POST /auth/logout-all instantly invalidates every outstanding token. Login and first-run are rate-limited (5/min per client). The realtime socket requires the same token; anonymous connections never receive log or console traffic.
• API: helmet security headers; CORS denies cross-origin by default (browsers reach the API same-origin through the web app). Serving the UI from a different origin needs CORS_ORIGINS (comma-separated allowlist).
• Docker access: least-privilege via docker-socket-proxy — see docker-compose.yml. The manager then only reaches container/image endpoints; exec, volumes, networks, build, and secrets are denied at the proxy. Note the proxy filters endpoints, not payloads: container creation stays possible, so this narrows the blast radius rather than eliminating it.
• Game containers run with no-new-privileges, a pids limit, and RAM caps; console/RCON arguments are sanitized against command injection from player-chosen names.
• Supply chain: CI blocks the image build on high/critical production dependency vulnerabilities (pnpm audit) and Trivy-scans the built image for CRITICAL CVEs before pushing; the base image is digest-pinned.
• Backups are verified: the manager's nightly DB snapshot must pass SQLite's integrity_check, and world backups record their size and raise a warning event when a snapshot captures no files.

Trade-off to know about: game-server images are pulled by floating tags (usually :latest, as their maintainers publish them). That's what keeps game updates one click away, but it means those images change underneath you outside Palisade's control. The game containers' runtime caps above (plus per-container RAM limits) bound what a misbehaving image can do — but treat game images with the same trust you'd give installing that community image by hand.

pnpm install

# generate secrets, then copy .env.example → .env
node -e "console.log('SECRETS_KEY=' + require('crypto').randomBytes(32).toString('hex'))"
node -e "console.log('JWT_SECRET='  + require('crypto').randomBytes(32).toString('hex'))"

pnpm --filter @ark/api db:push   # create the dev SQLite db
pnpm dev                         # API on :8787 + web on :3000
pnpm --filter @ark/api test      # unit tests

Monorepo layout: packages/shared (types + settings catalogs contract), apps/api (NestJS orchestrator), apps/web (Next.js UI), docker/ (manager entrypoint), unraid/ (CA template).

Palisade is a control plane — the actual game servers run on excellent community-maintained images. Huge thanks to their maintainers; this project wouldn't exist without them:

Also standing on: SteamCMD, GE-Proton/Wine for the Windows-only servers, Thunderstore (Valheim mod index), and the CurseForge + Steam Web APIs for mod browsing.

MIT © 2026 Jacob Neudorf. Not affiliated with Studio Wildcard, Overwolf/CurseForge, Valve, Iron Gate, The Fun Pimps, Keen Games, RocketWerkz, Funcom, Pocketpair, Mojang, or Netgate.