Pelican Panel Install & Setup Guide — Ubuntu 24.04, 2026

Pelican is the actively-maintained spiritual successor to Pterodactyl — same Wings-plus-Docker architecture, a cleaner UI, a first-time installer wizard, and a team that actually ships updates. This guide walks you from a blank Ubuntu 24.04 VPS to a working Pelican Panel with Wings, your first node, and your first game server running. Every command is verified against the official docs at pelican.dev.

01 // What Pelican actually is (and the Pterodactyl backstory)

Pelican is an open-source game server control panel (AGPL v3.0) that manages game servers running inside isolated Docker containers. One web UI, unlimited game servers, every server sandboxed so one crashed Minecraft instance can't take down your Rust box.

If that sounds exactly like Pterodactyl — it's because Pelican started as a fork of Pterodactyl in 2024 when upstream development slowed dramatically. Pelican picked up the baton, kept the core architecture (Panel written in PHP/Laravel + Wings daemon written in Go), and started shipping features the community had been asking for: a proper installer wizard, a modernised UI built on Filament v3, better resource graphs, and far more frequent releases.

02 // Key features

• Docker-isolated game servers — every server runs in its own container. No RAM or CPU cross-contamination, no port conflicts, no dependency hell.
• Guided installer wizard — at /installer on first visit. Pelican asks for your database details and creates the admin user through the browser. No artisan commands, no copy-pasting from forum threads.
• Egg system — "eggs" are JSON templates describing how to download, configure and run a specific game server. Huge community library covering almost every popular game.
• Pterodactyl egg compatibility — the egg format is essentially identical to Pterodactyl's. Most community Pterodactyl eggs import and run without modification (always test before trusting in production).
• Real-time console & file manager — browser console with full xterm emulation and an integrated file manager with syntax highlighting. No SSH needed for day-to-day work.
• Subuser permissions — grant fine-grained access per server. Give a moderator console access without giving them file or database access.
• SFTP with per-server credentials — connect via any SFTP client using Pelican-generated credentials scoped to a single server.
• Scheduled tasks & backups — cron-like scheduler for automatic restarts, backups, and console commands. S3-compatible backup destinations.
• Resource monitoring — live CPU/RAM/disk graphs per server plus enforced hard limits at the Docker level.
• OAuth / SSO — supports Discord, GitHub, Steam, and generic OAuth2 providers for user logins.

03 // Supported games

Pelican runs almost any game server that runs on Linux — if an egg exists (or you can write one), Pelican can run it. Popular community eggs include:

• Minecraft — Vanilla, Paper, Purpur, Spigot, Fabric, Forge, NeoForge, modpacks (ATM, FTB, Create, All the Mods, SkyFactory), Bedrock, BungeeCord/Velocity proxies
• Rust — vanilla, Oxide/uMod, Carbon
• ARK — Survival Evolved and Survival Ascended
• Source engine — Counter-Strike 2, Team Fortress 2, Garry's Mod, Left 4 Dead 2, CS:GO (legacy)
• Survival & co-op — Valheim, 7 Days to Die, Project Zomboid, The Forest, Sons of the Forest, Palworld, V Rising, Enshrouded
• FiveM & RedM — GTA V and RDR2 roleplay frameworks
• Other — Factorio, Terraria, Satisfactory, Squad, Arma 3, DayZ, Unturned, Starbound, Don't Starve Together

If a game isn't on this list, search the pelican-eggs GitHub organisation or the parkervcp/eggs repo (legacy Pterodactyl eggs, most import cleanly into Pelican).

04 // System requirements

These are taken directly from the official Pelican docs and verified against a fresh Ubuntu 24.04 install.

Software

• PHP 8.2, 8.3, 8.4 or 8.5 (8.3 recommended for stability in 2026). Required extensions: gd, mysql, mbstring, bcmath, xml, curl, zip, intl, sqlite3, fpm.
• Webserver — Nginx, Apache, or Caddy. This guide uses Nginx.
• Database — MySQL 8+, MariaDB 10.6+, PostgreSQL 14+, or SQLite (libsqlite3-0 3.35+). We use MariaDB for production and mention SQLite for tiny installs.
• Redis — optional but strongly recommended for session/cache storage. Ships in Ubuntu 24.04 repos.
• Docker CE — required by the Wings daemon. Install from get.docker.com, not from snap or the Ubuntu universe repo (both are outdated and cause issues).
• Composer 2 — for installing Panel PHP dependencies.
• Utilities — curl, tar, unzip, git.

Operating system

Officially supported: Ubuntu 22.04 / 24.04, Debian 11/12, Alma Linux 8/9/10, Rocky Linux 8/9/10, CentOS 10. This guide targets Ubuntu 24.04 LTS (the default image on most VPS providers in 2026). Commands translate to Debian 12 near-directly; for RHEL-family distros replace apt with dnf and adjust package names.

05 // Hardware scenarios — pick your tier

Pelican itself is light (~1–2 GB RAM in use under normal load). Your RAM budget goes to the game servers that Wings launches inside Docker. Size the VPS for the games you plan to host.

06 // Prepare the server

SSH into your fresh Ubuntu 24.04 VPS as root (or a sudoer). Everything below assumes root; prefix with sudo if you're on a sudoer account.

Update the system

apt update && apt upgrade -y

Set the timezone (optional but recommended)

timedatectl set-timezone Europe/Amsterdam

Pick your own zone — accurate timestamps matter in logs.

Install base utilities

apt install -y curl tar unzip git ca-certificates gnupg lsb-release software-properties-common

Open the required firewall ports

UFW isn't installed by default on 24.04, install and enable it:

apt install -y ufw
ufw default deny incoming
ufw default allow outgoing
ufw allow OpenSSH
ufw allow 80/tcp comment 'HTTP (Nginx + Wings cert renewal)'
ufw allow 443/tcp comment 'HTTPS (Panel)'
ufw allow 8080/tcp comment 'Wings API'
ufw allow 2022/tcp comment 'Wings SFTP'
ufw enable

07 // Install PHP 8.3 and extensions

Ubuntu 24.04 ships with PHP 8.3 in the default repos — no PPA needed anymore. Previous Pterodactyl guides use Ondrej's PPA; on 24.04 it's not required.

apt install -y php8.3 php8.3-{common,cli,gd,mysql,mbstring,bcmath,xml,fpm,curl,zip,intl,sqlite3,redis}

Verify the install:

php -v
# PHP 8.3.x (cli) (built: ...)

php -m | grep -E 'gd|mysql|mbstring|bcmath|xml|curl|zip|intl'
# Should list all of them

Install Composer 2

curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
composer --version
# Composer version 2.x.x

08 // Install MariaDB and create the database

SQLite is technically supported and fine for a tiny single-user setup, but MariaDB is the realistic choice for anything serious. It ships in the default Ubuntu 24.04 repos at version 10.11.

apt install -y mariadb-server mariadb-client
systemctl enable --now mariadb
mysql_secure_installation

Answer the mysql_secure_installation prompts:

• Switch to unix_socket auth? N (we want password auth for the pelican user)
• Change root password? Y and set a strong one
• Remove anonymous users? Y
• Disallow remote root login? Y
• Remove test database? Y
• Reload privilege tables? Y

Create the Pelican database and user:

mysql -u root -p

CREATE DATABASE panel;
CREATE USER 'pelican'@'127.0.0.1' IDENTIFIED BY 'YourStrongPasswordHere';
GRANT ALL PRIVILEGES ON panel.* TO 'pelican'@'127.0.0.1' WITH GRANT OPTION;
FLUSH PRIVILEGES;
EXIT;

09 // Download and set up the Pelican Panel

Pelican lives in /var/www/pelican by convention.

mkdir -p /var/www/pelican
cd /var/www/pelican
curl -L https://github.com/pelican-dev/panel/releases/latest/download/panel.tar.gz | tar -xzv
chmod -R 755 storage/* bootstrap/cache/

Install PHP dependencies with Composer:

composer install --no-dev --optimize-autoloader

When prompted about running as root, answer yes — this is a server install, Composer's warning is aimed at developer workstations.

10 // Configure Nginx with SSL

Install Nginx and Certbot:

apt install -y nginx certbot python3-certbot-nginx

Point your domain's A record at the VPS IP before the next step (panel.yourdomain.com → your.vps.ip.address). Verify with dig panel.yourdomain.com +short before continuing or Certbot will fail.

Create the Pelican Nginx config at /etc/nginx/sites-available/pelican.conf:

server {
    listen 80;
    server_name panel.yourdomain.com;

    root /var/www/pelican/public;
    index index.php;

    access_log /var/log/nginx/pelican.app-access.log;
    error_log  /var/log/nginx/pelican.app-error.log error;

    client_max_body_size 100m;
    client_body_timeout 120s;

    sendfile off;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param PHP_VALUE "upload_max_filesize=100M \n post_max_size=100M";
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param HTTP_PROXY "";
        fastcgi_intercept_errors off;
        fastcgi_buffer_size 16k;
        fastcgi_buffers 4 16k;
        fastcgi_connect_timeout 300;
        fastcgi_send_timeout 300;
        fastcgi_read_timeout 300;
    }

    location ~ /\.ht {
        deny all;
    }
}

Replace panel.yourdomain.com with your actual subdomain. Enable the site and remove the default:

ln -s /etc/nginx/sites-available/pelican.conf /etc/nginx/sites-enabled/pelican.conf
rm /etc/nginx/sites-enabled/default
nginx -t
systemctl reload nginx

Get a Let's Encrypt certificate:

certbot --nginx -d panel.yourdomain.com

Certbot will automatically edit the Nginx config to add the SSL server block and redirect HTTP to HTTPS. Renewal runs automatically via systemd timer.

Set correct file ownership

chown -R www-data:www-data /var/www/pelican/

11 // Run the Pelican installer wizard

This is where Pelican genuinely leaves Pterodactyl behind. Instead of ten php artisan commands to configure env, run migrations and create an admin user, Pelican gives you a browser wizard.

Open https://panel.yourdomain.com/installer in your browser.

Wizard steps

1. Environment check — Pelican verifies PHP version, extensions, file permissions, and writable paths. Fix anything red before continuing (usually just a missing PHP extension).
2. Database — choose MySQL/MariaDB, host 127.0.0.1, port 3306, database panel, user pelican, password you set earlier. Pelican tests the connection live.
3. Cache, session, queue drivers — Redis for all three if you installed it (recommended). Database is fine if you skipped Redis.
4. App URL & timezone — https://panel.yourdomain.com and your timezone.
5. Admin user — email, username, password. This is your first administrator account.
6. Finalise — Pelican writes .env, runs migrations, seeds default data, and redirects you to the login page.

12 // Queue worker and scheduled tasks

Pelican uses Laravel's queue and scheduler for backups, server provisioning, power actions, and cleanup. Both need to run continuously. Set up a systemd service for the queue worker and a cron entry for the scheduler.

Crontab for the scheduler

crontab -e

Add this single line at the bottom:

* * * * * php /var/www/pelican/artisan schedule:run >> /dev/null 2>&1

Systemd unit for the queue worker

Create /etc/systemd/system/pelican-queue.service:

[Unit]
Description=Pelican Queue Worker
After=redis-server.service

[Service]
User=www-data
Group=www-data
Restart=always
ExecStart=/usr/bin/php /var/www/pelican/artisan queue:work --queue=high,standard,low --sleep=3 --tries=3
StartLimitInterval=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now pelican-queue.service
systemctl status pelican-queue.service

You should see active (running). If it's failing, check journalctl -u pelican-queue -n 50 — the most common cause is a permission issue on storage/logs/ (run chown -R www-data:www-data /var/www/pelican again).

13 // Install Docker

Wings runs game servers inside Docker containers, so Docker is mandatory. Use the official Docker CE repo — do not use the docker.io package from Ubuntu's universe repo or the snap version. Both are outdated and cause Wings to misbehave.

curl -sSL https://get.docker.com/ | CHANNEL=stable bash
systemctl enable --now docker
docker --version
# Docker version 27.x or newer

Enable swap accounting in the kernel so Wings can enforce per-container memory limits that include swap:

nano /etc/default/grub

Find the GRUB_CMDLINE_LINUX_DEFAULT line and change it to:

GRUB_CMDLINE_LINUX_DEFAULT="swapaccount=1"

Then:

update-grub
reboot

(If the panel is on a different host than Wings, only the Wings host needs this kernel flag.)

14 // Install the Wings daemon

Wings is the Go binary that talks to Docker and the Panel. It runs on every node that hosts game servers.

Download Wings

mkdir -p /etc/pelican /var/run/wings
curl -L -o /usr/local/bin/wings "https://github.com/pelican-dev/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"
chmod u+x /usr/local/bin/wings
wings --version

Create the Wings systemd service

Create /etc/systemd/system/wings.service:

[Unit]
Description=Pelican Wings Daemon
After=docker.service
Requires=docker.service
PartOf=docker.service

[Service]
User=root
WorkingDirectory=/etc/pelican
LimitNOFILE=4096
PIDFile=/var/run/wings/daemon.pid
ExecStart=/usr/local/bin/wings
Restart=on-failure
StartLimitInterval=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable wings

Don't start Wings yet — it needs a config file, which Pelican generates when you create the node. That's next.

15 // Create your first node and link Wings

A node in Pelican terminology is a machine running Wings. Even if your panel and Wings are on the same VPS, you still register it as a node in the UI.

In the Pelican admin UI

1. Log in at https://panel.yourdomain.com with the admin account you created in the wizard.
2. Open Admin → Nodes → Create New.
3. Name: node01 (or anything).
4. Location: create one first (e.g. eu-west) from Admin → Locations — it's just a label for organisation.
5. FQDN: a domain that points to this Wings host (e.g. node01.yourdomain.com). If you only have an IP, pick Use only IP Address. SSL is recommended; use Let's Encrypt.
6. Daemon Port: 8080. SFTP Port: 2022.
7. Memory / Disk allocation: the amount of system RAM/disk Wings is allowed to hand out to game servers. Leave ~2 GB of RAM for the host OS and panel.
8. Save.

Grab the Wings config and drop it on the node

On the node page, open the Configuration tab. Pelican generates a YAML block. Copy it.

On the Wings host:

nano /etc/pelican/config.yml

Paste the YAML, save, then start Wings:

systemctl start wings
systemctl status wings

You should see active (running). Back in the panel, the node status indicator should turn green within 10 seconds.

Create an allocation (IP + port combo)

On the node's Allocations tab, add the public IP and the port range you want to use for game servers. For example IP 1.2.3.4 with ports 25565-25585 for a Minecraft block, or 28015-28035 for a Rust block. Each allocation is what Pelican assigns to a server when you create one.

16 // Create your first game server

Pelican ships with a few default eggs (Minecraft Vanilla, Paper, Forge, and a handful of Source games). We'll create a Minecraft Paper server as a test.

1. Admin → Servers → Create New Server.
2. Owner: your admin user (or create a dedicated user first).
3. Node: the node you just created.
4. Allocation: pick one from the list (e.g. the first 25565 port).
5. Resource limits: CPU: 200 (= 2 cores worth), Memory: 4096 MB, Disk: 10000 MB. Adjust to your server's capacity.
6. Nest / Egg: Minecraft → Paper.
7. Startup variables: usually the defaults work. Accept the EULA variable by setting it to true (you're agreeing to Mojang's EULA on the end user's behalf).
8. Save. Pelican queues an install job; Wings downloads the Paper jar, unpacks the server, and writes the initial config.

Once the install finishes (watch Manage → Installation Logs), go to the user-facing side of Pelican (log out of admin, log back in as a normal user or use View as User) and hit Start. You should see Paper boot, generate the world, and accept connections on the allocation port.

17 // Admin panel tour — what lives where

Pelican's admin UI is organised into clean sections. A quick map so you know where to go:

• Servers — list, create, suspend, reinstall, or delete game servers across all nodes.
• Users — create panel users, grant admin rights, set per-user resource limits.
• Nodes — your Wings hosts. Monitor load, manage allocations, pull the Wings config.
• Locations — groupings for nodes (regions, datacenters).
• Nests & Eggs — the server templates. A "nest" is a category (Minecraft, Source Engine, Rust) and "eggs" are individual server types inside that nest (Paper, Forge, Vanilla).
• Mounts — bind-mount host paths into specific servers (useful for shared world data or large read-only assets).
• Databases — per-server MySQL/MariaDB databases that Pelican can create automatically for plugins or mods.
• API — generate application and client API keys for automation.
• Settings — app name, branding, mail config, OAuth providers, reCAPTCHA.

18 // Importing Pterodactyl eggs

The single biggest ecosystem advantage Pelican has is inheriting Pterodactyl's massive egg library. If the default eggs don't cover your game, grab one from the community.

Where to find eggs

• pelican-eggs GitHub organisation — maintained Pelican-native eggs, first-class support.
• parkervcp/eggs — the legendary Pterodactyl community egg repo. Most eggs here import into Pelican unchanged.
• Individual game communities often publish their own eggs on GitHub or Discord (e.g. the FiveM and Palworld communities).

How to import an egg

1. Download the egg-*.json file (right-click → Save Link As on GitHub).
2. In Pelican: Admin → Nests.
3. Open the nest you want (or create a new one, e.g. Palworld).
4. Click Import Egg, upload the JSON, confirm.
5. The new egg appears and is immediately available when creating a server.

Test before trusting

Community eggs are scripts that run as part of server installation. Read the install script in the egg JSON before importing one from an unfamiliar source — a malicious egg could run arbitrary commands during install. Eggs from pelican-eggs and parkervcp are vetted; random forks of forks are not.

19 // Backups

Pelican has backups built in. Two destination types are supported out of the box: local (on the Wings host) and S3-compatible (AWS S3, Wasabi, Backblaze B2, MinIO, Cloudflare R2).

Local backups

By default backups go to /var/lib/pelican/backups/ on the Wings host. Fine for convenience, not fine as your only copy — if the host dies, your backups die with it.

S3-compatible backups (recommended)

Cloudflare R2 is the cheapest realistic option in 2026 (zero egress fees, ~$0.015/GB/month). Create an R2 bucket, generate an access key pair, then in Pelican: Admin → Settings → Backups and fill in:

• Adapter: S3
• Access Key / Secret: from R2
• Bucket: your R2 bucket name
• Region: auto
• Endpoint: https://<accountid>.r2.cloudflarestorage.com

Save. Now when a user hits Backup Now on their server, Pelican uploads the tarball to R2 and tracks it in the panel database.

Scheduled backups

On any server, open Schedules → Create New. Set 0 4 * * * (daily 4 AM) with a single task: Create Backup. Enable it. Done — nightly automatic backups forever, per server, with retention controlled by the backup limit you set when creating the server.

20 // OAuth / SSO

Let your users log in with Discord, GitHub or Steam instead of managing another password. In Admin → Settings → OAuth:

• Discord — create an application at discord.com/developers/applications, copy the client ID and secret, add redirect URI https://panel.yourdomain.com/auth/oauth/callback/discord.
• GitHub — Settings → Developer Settings → OAuth Apps on github.com. Same flow.
• Steam — requires a Steam Web API key from steamcommunity.com/dev/apikey.

Enable the ones you want, save, and the corresponding buttons appear on your login page.

21 // API keys and automation

Pelican exposes two APIs:

• Application API — admin operations (create users, provision servers, pull stats). Keys live at Admin → API.
• Client API — end-user operations (start/stop servers, pull console output, upload files). Keys live in the user's account settings.

Full reference: pelican.dev/docs/api/api-usage. Common use cases: writing a billing integration, hooking Pelican to a Discord bot for server controls, or auto-provisioning servers from a website form.

22 // Honest pros and cons

Pros

• Actively maintained — releases every few weeks in 2026, compared to months of silence upstream on Pterodactyl.
• Installer wizard saves ~45 minutes — the single biggest onboarding win over Pterodactyl.
• Modern UI — built on Filament v3, fast, legible, looks like it belongs in 2026.
• Free and open source — AGPL v3.0. No license fees ever.
• Docker isolation — inherited from Pterodactyl, still the right architecture.
• Egg compatibility with Pterodactyl — huge head start on game coverage.
• Healthy Discord community — fast answers, active development team, responsive to bug reports.

Cons

• Still requires Linux knowledge — the installer wizard helps but you still need to set up Nginx, Certbot, systemd, Docker by hand. Not a one-click affair.
• Younger project — fewer Stack Overflow answers when things go weird. You'll be reading GitHub issues and Discord threads.
• Some Pterodactyl eggs need schema tweaks — 90% work unchanged, 10% need a version bump in the JSON.
• Third-party theme/mod ecosystem is thinner than Pterodactyl's (which has been around longer).
• Wings resource usage — the daemon idles around 100 MB RAM. Tiny on a KVM 2, noticeable on a KVM 1.

23 // How Pelican compares to alternatives

Pelican vs Pterodactyl

• Architecture: identical (PHP/Laravel panel + Go Wings daemon + Docker isolation).
• Installation: Pelican wins clearly — browser wizard vs artisan commands.
• UI: Pelican's is newer and cleaner. Pterodactyl's is fine but feels dated.
• Update cadence: Pelican ships monthly-ish. Pterodactyl has been quiet.
• Community: Pterodactyl's is larger but aging. Pelican's is smaller but growing fast.
• Eggs: Pelican can use Pterodactyl's library with minor tweaks.
• Verdict 2026: Pelican for new installs. Stay on Pterodactyl only if you're already happily running it.

Pelican vs AMP by CubeCoders

• Cost: Pelican free forever. AMP has a one-time license fee.
• Game coverage: AMP has more built-in "official" game templates (100+). Pelican matches via community eggs.
• Polish: AMP feels like a commercial product. Pelican feels like a well-loved open-source one.
• Isolation: AMP uses systemd units, not Docker. Less isolation but simpler to reason about.
• Verdict: AMP for beginners who want polish and don't mind paying. Pelican for anyone comfortable with Docker and who wants full open-source control.

Full comparison: AMP Panel install guide.

Pelican vs LinuxGSM

• Interface: LinuxGSM is CLI-only. Pelican has a full web UI.
• Multi-tenancy: LinuxGSM runs servers as regular Linux users. Pelican has real user accounts, permissions, subusers.
• Learning curve: LinuxGSM is lower at the start (one bash command per server) but hits a ceiling fast. Pelican takes longer to set up but scales to dozens of servers cleanly.
• Verdict: LinuxGSM for a single personal game server. Pelican once you have 3+ servers or want to give others controlled access.

See also: LinuxGSM install guide.

24 // Common issues & fixes

Installer wizard returns a 500 error

Almost always a permissions issue on storage/ or bootstrap/cache/. Fix:

chown -R www-data:www-data /var/www/pelican
chmod -R 755 /var/www/pelican/storage /var/www/pelican/bootstrap/cache

Then tail the log to find the actual error:

tail -f /var/www/pelican/storage/logs/laravel.log

Node shows offline (red) in the panel

1. Is Wings actually running? systemctl status wings
2. Is port 8080 reachable from the panel host? curl -vk https://node01.yourdomain.com:8080
3. Does the Wings cert match the FQDN? Check journalctl -u wings for SSL errors.
4. If panel and Wings are on the same host: confirm the panel's Docker network isn't masking the Wings port. Firewall rules with conflicting priorities are a common culprit.

Server installation stuck at 0%

Means Wings can't pull the Docker image. Check journalctl -u wings -n 100 — usually it's a DNS issue inside Docker or an outbound firewall rule blocking hub.docker.com. Fix DNS by adding to /etc/docker/daemon.json:

{
  "dns": ["1.1.1.1", "1.0.0.1"]
}

systemctl restart docker wings

Minecraft server OOM-killed repeatedly

The JVM will ask for more than the server's memory limit and get killed. Two fixes in order of preference:

• Give the server more memory in Manage → Settings.
• In the server's startup variables, lower the allocated Java heap (-Xmx) so the JVM stays under the container limit with headroom for metaspace and off-heap buffers (roughly heap + 1 GB = container memory).

Tuning deep-dive: Minecraft Java JVM flags guide.

SFTP login refused on port 2022

Pelican runs its own SFTP server inside Wings — not OpenSSH. The username is username.serverShortId (the panel shows it in Settings → SFTP). The password is your Pelican login password. Common gotcha: you typed your SSH password, not your Pelican password.

25 // Updating Pelican

Pelican has an artisan command that does the whole update in one go. It pulls the latest release, runs migrations, and clears caches.

cd /var/www/pelican
php artisan p:upgrade

That's it. The command handles maintenance mode automatically (panel returns a friendly "updating" page during the upgrade). Takes 30–60 seconds on a typical VPS.

For Wings, on each node:

systemctl stop wings
curl -L -o /usr/local/bin/wings "https://github.com/pelican-dev/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"
chmod u+x /usr/local/bin/wings
systemctl start wings

Running game servers briefly pause during the Wings restart but come back up automatically.

26 // Next steps

• Add a second node — Pelican shines with multiple nodes. Repeat the Wings install on another VPS, add it in the panel, and you can allocate servers to whichever node has capacity.
• Set up automatic nightly backups to S3 — covered above. Do this before you have users who'll be angry if their save is lost.
• Configure mail — Admin → Settings → Mail. Use Resend, Postmark, or SES for transactional. Without mail, password resets don't work.
• Enable 2FA — every admin account should have it on. Settings → Security in the user profile.
• Write your own egg — once you've run a few community eggs you'll understand the format well enough to write one for a game that doesn't have one yet. The official egg docs are the canonical reference.
• Harden the server — fail2ban for SSH, unattended-upgrades for security patches, regular apt upgrade cycles.

27 // Final thoughts

In 2026, Pelican is the correct default choice for a self-hosted game server control panel. The installation is still not a one-clicker — you're installing PHP, MariaDB, Nginx, Docker, and Wings — but the installer wizard has removed the single most painful step (the initial configuration), and the UI is pleasant to spend time in. The community is the right size: small enough to get real answers on Discord, big enough that most problems have already been solved by someone.

If you've made it to the end of this guide with a working Pelican install, a running Wings node, and a game server you can start and stop from a browser — congratulations, you've just built the same foundation that hundreds of game hosting companies run as a production service. Everything else is polish.