Pelican Panel Install & Setup Guide on Ubuntu 24.04

Pelican is the modern fork of Pterodactyl built by the original core team after a governance split in 2024. It ships with a browser-based installer wizard (no more editing .env files by hand), a cleaner admin UI, and identical Wings-compatible architecture. This guide covers the full production install on Ubuntu 24.04 — Docker, Wings, nginx with Let's Encrypt SSL, 2FA, backups, and your first game server. If you already run Pterodactyl, the migration path is at the end.

01 // What Pelican actually is

Pelican is an open-source game server management panel — a web UI that lets you and your users create, configure, start, stop, and console into game servers without touching SSH. It ships under the MIT license, free forever, self-hosted on your own VPS. Architecturally it is a Laravel + Livewire panel on one side, and a Go daemon called Wings on the other side that actually runs game servers inside isolated Docker containers.

If that description sounds exactly like Pterodactyl — that's because Pelican is a direct fork of it. The important differences are covered in the next section. For now the one-line summary: Pelican is Pterodactyl, built by the original team, with a modern browser installer and a cleaner UI.

02 // The Pterodactyl fork — the honest backstory

In mid-2024 the Pterodactyl core maintainers (Matthew Penner and team) left the original Pterodactyl organization over governance disputes with the project's new ownership. Rather than abandon the codebase they had written over the previous decade, they forked it as Pelican and kept shipping. The original Pterodactyl organization continued with different maintainers. Both projects still exist today.

What this means for you as an admin in 2026:

• Pelican gets the faster modern updates — the core devs who wrote the panel are the ones pushing features. Browser installer, new UI refresh, Laravel 11, PHP 8.3 baseline — all Pelican-first.
• Pterodactyl still works — it's not dead. There are still patches and the huge community of existing eggs and addons remains compatible with both.
• Wings is the same protocol — a Wings daemon can in principle connect to either panel, because Pelican didn't break the node protocol. Eggs are interchangeable. Migrating between the two is possible.
• Community split — some addon developers went with Pelican, some stayed Pterodactyl. Most support both. Check before installing a third-party theme or addon.

For a brand new install in 2026, we recommend Pelican — it's more actively developed, the installer is genuinely better, and the team behind it wrote the original code. If you already run Pterodactyl and it's working, there is no urgent reason to switch. For the full side-by-side breakdown, see our Pterodactyl vs Pelican comparison.

03 // The browser installer wizard — the big differentiator

Pterodactyl's install process has a reputation: install dependencies by hand, cp .env.example .env, php artisan key:generate, php artisan p:environment:setup, then half a dozen database and mail commands in a specific order, then pray. Every copy-paste tutorial on the internet has a slightly different sequence, and getting one step wrong leaves you with a half-configured .env file.

Pelican replaces all of that with a single install script + a browser wizard. The flow is:

1. Run one official install script — it handles PHP 8.3, Composer, the database, Redis, the Laravel storage link, and the queue worker.
2. Open your panel URL in a browser. You land on /installer.
3. The wizard walks you through: environment check, database credentials, Redis connection, admin user creation, and panel URL config.
4. When you click Finish, the wizard writes the .env file, runs migrations, seeds the database, and drops you at the login page.

No hand-editing .env. No memorizing artisan commands. If a step fails, the wizard tells you what's wrong in plain English (wrong DB password, Redis not running) instead of a Laravel stack trace in your SSH session.

04 // Requirements

Pelican itself is lightweight — it's a PHP/Laravel app plus a Go daemon. The RAM you need is almost entirely dictated by the game servers you plan to run on top of it, not the panel.

• OS — Ubuntu 24.04 LTS (recommended) or Ubuntu 22.04 LTS. Debian 12 works. We use Ubuntu 24.04 in every command below.
• CPU — 2 vCPU minimum for the panel + 1 light game server. Add cores per additional game server.
• RAM (panel only) — 2 GB is enough for the panel plus Wings idle. Game servers are on top of this.
• RAM (panel + 1–2 game servers) — 8 GB minimum for anything serious. 16 GB recommended if you run Rust, modded Minecraft, or ARK.
• Storage — 50 GB SSD/NVMe minimum. Game server files + Docker images + backups eat space faster than you expect.
• Software — PHP 8.3, MariaDB 10.11+ (or MySQL 8), Redis 7+, Composer 2, Docker Engine 24+, Node.js 20+ (used during install).
• Network — a domain name pointed at the server (panel.yourdomain.com). Ports 80, 443 open to the world, 22 open to your admin IP, 8080 + 2022 open for Wings.
• Root access — full root or a sudo user. This is a real install, not a managed panel.

05 // Server prep & dependencies

SSH into your VPS as root or a sudo user. Everything that follows assumes $USER has sudo. Start by updating the system:

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl wget git ca-certificates gnupg lsb-release software-properties-common ufw

Set the hostname and timezone (small detail, saves headaches in logs later):

sudo hostnamectl set-hostname panel
sudo timedatectl set-timezone Etc/UTC

Lock down the firewall before the panel goes live. Replace YOUR.ADMIN.IP.HERE with your own IP so SSH isn't open to the world:

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow from YOUR.ADMIN.IP.HERE to any port 22 proto tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 8080/tcp   # Wings API
sudo ufw allow 2022/tcp   # Wings SFTP
sudo ufw enable
sudo ufw status verbose

06 // Install the Pelican panel

Pelican ships an official install script that handles PHP 8.3, MariaDB, Redis, Composer, Nginx, and the Laravel setup in one go. Run it as root:

cd /tmp
curl -Lo pelican-installer.sh https://pelican.dev/install.sh
sudo bash pelican-installer.sh

The script will ask a few questions:

• Panel domain — the subdomain that will host the panel, e.g. panel.yourdomain.com. Point its A record at this server before running the installer, or SSL provisioning will fail.
• Admin email — used for Let's Encrypt registration and the default admin account.
• Database password — auto-generated if you accept the default; noted in the installer summary. Save it.
• Enable HTTPS (Let's Encrypt)? — answer y. The installer runs certbot against your domain and configures nginx automatically.

On a KVM 2 with a 100 Mbit connection the full install takes about 4–6 minutes. When it finishes the installer prints the panel URL and a success message.

Complete the browser installer wizard

Open https://panel.yourdomain.com in a browser. You'll land on /installer. The wizard has five steps:

1. Environment check — Pelican verifies PHP extensions, writable directories, and the web server. Any red X here means a missing dependency — almost always solved by re-running the install script.
2. Database — fields are pre-filled from the install script. Click Test Connection, then Next.
3. Redis — default values (127.0.0.1:6379, no password) work for a single-server install. Click Test, then Next.
4. Admin user — create your first admin account. This is the account you'll log in with, so pick a strong password and save it in a password manager.
5. Panel settings — panel URL (pre-filled with your HTTPS domain), timezone, and default language. Click Finish.

The wizard writes .env, runs migrations and seeders, and redirects you to the login screen. Log in with the admin account you just created. You should see an empty dashboard with no nodes and no servers. That's expected — Wings isn't installed yet.

07 // Install Wings — the daemon that runs game servers

The panel is a web UI. The thing that actually runs game servers inside Docker containers is called Wings. Wings can live on the same VPS as the panel (single-node setup, covered here) or on separate machines (multi-node, a whole other topic).

Install Docker Engine first — the official Docker repo, not the Ubuntu-packaged version which lags behind:

curl -fsSL https://get.docker.com | sudo sh
sudo systemctl enable --now docker
docker --version   # expect 24.x or newer

Now install the Wings binary:

sudo mkdir -p /etc/pelican /var/lib/pelican /var/log/pelican /srv/pelican
sudo 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)"
sudo chmod u+x /usr/local/bin/wings
wings --version

Create the Wings systemd unit — copy this block exactly:

sudo tee /etc/systemd/system/wings.service >/dev/null <<'UNIT'
[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
UNIT
sudo systemctl daemon-reload

Don't start Wings yet — it needs a config file first, and that file comes from the panel.

08 // Link the Wings node to the panel

Log back into the panel as admin. Go to Admin → Nodes → Create New. Fill in:

• Name — main (or whatever you want to call this physical server)
• Location — click the link next to the Location field to create one (e.g. eu-west) if none exist
• FQDN — panel.yourdomain.com (same as panel if Wings is on the same server, different subdomain if remote)
• Communicate over SSL — Yes
• Behind Proxy — No (unless you specifically put Wings behind Cloudflare)
• Total Memory / Disk — set these to your VPS's total capacity minus ~1 GB RAM for the OS and panel. On a KVM 2 with 8 GB: allocate 7168 MB.
• Daemon Port — 8080 / SFTP Port — 2022 (defaults)

Click Create. On the new node's page open the Configuration tab. Click Generate Token, then copy the full auto-deploy command or the config.yml block it shows.

Back on the VPS SSH session, paste the config block into the Wings config file:

sudo nano /etc/pelican/config.yml
# paste the full config the panel generated, save with Ctrl+O Enter, exit Ctrl+X

Start Wings:

sudo systemctl enable --now wings
sudo systemctl status wings --no-pager

Within a few seconds the panel's node page should flip the status indicator to green. If it doesn't, check Wings logs: sudo journalctl -u wings -n 100 --no-pager.

Now add an allocation — an IP + port combo the panel can assign to game servers. On the node page go to Allocations → Assign New. Enter your server's public IP and a range like 25565-25580 (good for Minecraft — broad enough for a few servers). Click Submit.

09 // Create your first game server (Paper Minecraft)

Pelican ships with a library of eggs — templates that know how to install and run specific games. Paper (Minecraft Java) is included out of the box.

Go to Admin → Servers → Create New. Fill in:

• Server Name — paper-01
• Owner — your admin account (you can reassign later)
• Node — main
• Allocation — pick any port in the 25565–25580 range
• Memory — 4096 MB is a reasonable start for a small Paper server
• Disk Space — 10240 MB
• CPU Limit — 200 (= 2 cores; 0 means unlimited)
• Nest / Egg — Minecraft → Paper
• Startup Variables — leave defaults, or pick a specific Minecraft version

Click Create Server. The egg downloads the Paper jar, writes eula.txt, and sets up the startup script. Watch the install console in the panel — a clean install finishes in under 60 seconds.

Once the server status shows Offline (installed), click Start. In 15 seconds you should see the Minecraft welcome line: Done (X.XXXs)! For help, type "help". Connect from a Minecraft client using yourdomain.com:25565 (or whatever port you allocated) and you're in.

10 // Interactive RAM planner — how much do I actually need?

The most common Pelican support question is "how much RAM should I allocate to each server?" This calculator gives you a realistic answer based on game type and player count. All values are from real production servers we run.

11 // Nginx reverse proxy & SSL (manual config if needed)

The official install script configures nginx + Let's Encrypt for you. This section is for admins who skipped the script or need to rebuild the nginx config by hand.

Install nginx and certbot:

sudo apt install -y nginx certbot python3-certbot-nginx

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

server {
    listen 80;
    server_name panel.yourdomain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name panel.yourdomain.com;

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

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

    client_max_body_size 100m;
    client_body_timeout 120s;
    sendfile off;

    ssl_certificate /etc/letsencrypt/live/panel.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/panel.yourdomain.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;

    add_header X-Content-Type-Options nosniff;
    add_header X-Frame-Options SAMEORIGIN;
    add_header X-XSS-Protection "1; mode=block";

    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; }
}

Enable the site and get a cert:

sudo ln -s /etc/nginx/sites-available/pelican.conf /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl reload nginx
sudo certbot --nginx -d panel.yourdomain.com --agree-tos -m admin@yourdomain.com --redirect

Certbot installs a systemd timer that renews certificates automatically. Verify it's active:

sudo systemctl list-timers | grep certbot
sudo certbot renew --dry-run

12 // Queue worker & cron (the bit everyone forgets)

Pelican has two background processes that must be running or things start to silently break: the queue worker (handles server transfers, email sending, scheduled tasks) and the cron (runs every minute for scheduled operations). The install script sets these up — verify they're alive:

systemctl status pelican-queue --no-pager
crontab -u www-data -l

You should see the pelican-queue.service active and a cron entry running php /var/www/pelican/artisan schedule:run every minute. If either is missing, this is how to recreate them:

sudo tee /etc/systemd/system/pelican-queue.service >/dev/null <<'UNIT'
[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
UNIT
sudo systemctl daemon-reload
sudo systemctl enable --now pelican-queue

sudo crontab -u www-data -e
# Add this line:
* * * * * php /var/www/pelican/artisan schedule:run >> /dev/null 2>&1

13 // Enable 2FA on every admin account

A panel with admin access can start/stop/delete game servers and read any file on any node. Without 2FA, a leaked password is a full compromise. Pelican supports TOTP 2FA out of the box — turn it on right now, before you do anything else. For the full hardening playbook (UFW, fail2ban, Cloudflare Tunnel, MariaDB/Redis lockdown, audit checklist), see our Pterodactyl & Pelican security hardening guide.

1. Log in → click your username top-right → Account Settings.
2. Two-Factor Authentication → Configure.
3. Scan the QR code in Authy, 1Password, Bitwarden, Google Authenticator — any TOTP app.
4. Enter the 6-digit code. Pelican shows you recovery codes — save these offline. If you lose your phone and don't have them, you're locked out.
5. Force 2FA for all users: Admin → Settings → Security → Require 2FA → set to "All Users".

14 // Backup strategy that actually works

Pelican has a built-in backup feature that creates tarballs of individual game servers (worlds, configs, plugins). That's necessary but not sufficient. You also need to back up the panel's database — lose that and you lose every user account, server config, and scheduled task, even if the game server files are safe.

Set up a nightly script that dumps the database, tars the panel directory, and ships it to remote storage. Create /usr/local/bin/pelican-backup.sh:

#!/bin/bash
set -e
BACKUP_DIR=/var/backups/pelican
DATE=$(date +%Y%m%d-%H%M%S)
mkdir -p $BACKUP_DIR

# Database dump
mysqldump --single-transaction --routines --triggers panel > $BACKUP_DIR/pelican-db-$DATE.sql

# Panel files (excluding cache)
tar -czf $BACKUP_DIR/pelican-files-$DATE.tar.gz \
    --exclude='/var/www/pelican/storage/framework/cache' \
    --exclude='/var/www/pelican/storage/logs' \
    /var/www/pelican /etc/pelican

# Retention: 14 days local
find $BACKUP_DIR -type f -mtime +14 -delete

# Ship offsite (pick one): rclone/aws s3/rsync to another VPS
# rclone copy $BACKUP_DIR remote:pelican-backups/ --transfers=4

sudo chmod +x /usr/local/bin/pelican-backup.sh
sudo crontab -e
# Add:
30 3 * * * /usr/local/bin/pelican-backup.sh >> /var/log/pelican-backup.log 2>&1

Per-server game data backups are configured from inside the panel: Server → Backups → Create Backup. Users on each server can manage their own. For automated rolling backups, use a scheduled task (Server → Schedules → Create Schedule → Action: Create Backup, daily at 4am).

15 // Troubleshooting — real failures you will hit

Everything below is pulled from actual Pelican support threads and our own install sessions. These are the 12 failures that come up most often.

16 // Migrating from Pterodactyl to Pelican

Pelican provides a first-party migration command that imports your existing Pterodactyl database. Because both projects share the same schema lineage, the migration is mostly a copy + schema-update operation rather than a full data rewrite.

High-level steps:

1. Take a full backup of the Pterodactyl database and /var/www/pterodactyl directory first. Non-negotiable.
2. Stop the Pterodactyl panel, queue worker, and any pterodactyl cron.
3. Install Pelican fresh on a new machine (or the same one after moving Pterodactyl aside).
4. Run Pelican's php artisan p:upgrade:pterodactyl command, pointing at the old DB credentials.
5. Update Wings config remote: URL to point at the new Pelican panel, restart Wings.
6. Verify servers start, users can log in, and 2FA still works (may need to re-enroll).

Full migration docs live at pelican.dev/docs. If you run a production Pterodactyl instance with real users, migrate on a staging VPS first.

17 // Pelican vs Pterodactyl — honest comparison

If you came here from the Pterodactyl guide and want to know whether to pick the fork instead, here is the honest answer based on running both in production.

Our take: if you are installing fresh today and don't have a Pterodactyl infrastructure you are attached to, pick Pelican — the browser installer alone saves 30+ minutes per new node. If you are running production with 20+ servers and happy eggs, there is no urgent reason to migrate; Pterodactyl is not going anywhere.

18 // Next steps

• Deploy your real games — Minecraft Java performance tuning, Rust dedicated server, CS2 server, TF2 community server.
• Compare alternatives — read our Pterodactyl guide to see what the fork relationship actually looks like in practice, and AMP by CubeCoders if you want a paid one-click alternative.
• Don't want to run any of this? Our hosting reviews cover managed providers (Physgun, Shockbyte, Nitrado) that handle the panel for you.
• Size your VPS properly — use our VPS sizer tool to pick the right Hostinger plan for your expected server load.

19 // Frequently asked questions