FastDL Setup for CS2 and TF2 — Custom Maps Without the Wait

Custom maps on a Source engine server without FastDL download at roughly 50 KB/s over the game’s UDP channel. A 30 MB map takes ten minutes and most players just disconnect. This guide sets up a lightweight nginx FastDL server on the same VPS as your game server — no extra cost — so maps download 50–100× faster over HTTPS. Works for TF2, CS2, CS:S, GMod, L4D2, and every Source engine game.

01 // What FastDL Is and Why It Matters

FastDL (Fast Download) is a feature built into every Source engine game. When a player connects and is missing a custom asset — a map, model, sound, or material — the client normally downloads it from the game server over the same UDP connection used for gameplay. That connection is capped at roughly 20–50 KB/s, which is fine for a 500 KB config file and catastrophic for a 60 MB custom map.

FastDL fixes this by telling the client: “if you’re missing a file, grab it from this URL instead”. The URL is typically a plain HTTP(S) web server serving the same asset folders over TCP. Download speeds jump from ~50 KB/s to whatever the player’s connection can pull from your web server — usually 2–20 MB/s.

02 // When Do You Actually Need FastDL?

03 // The Architecture: Game Server + nginx on the Same VPS

The simplest, cheapest, and most reliable FastDL setup runs nginx on the same VPS as your game server. No separate hosting bill, no cross-network latency, no CORS headaches. The game server lives in /home/tf2/ or /home/cs2/ and nginx serves a mirror of its asset folders from /var/www/fastdl/.

/home/tf2/serverfiles/tf/maps/cp_orange_x3.bsp       ← game server reads this
/var/www/fastdl/tf/maps/cp_orange_x3.bsp.bz2         ← nginx serves this (compressed)
/var/www/fastdl/tf/maps/cp_orange_x3.bsp             ← optional fallback (uncompressed)

When a player connects and is missing cp_orange_x3.bsp, the client hits https://fastdl.yourdomain.com/tf/maps/cp_orange_x3.bsp.bz2, downloads at full speed, decompresses locally, and joins. Total time: 3–8 seconds instead of 10 minutes.

04 // Requirements

• A VPS running Ubuntu 22.04 or 24.04 LTS — same one your game server is on is fine; FastDL is extremely light.
• Root or sudo access — to install nginx and edit firewall rules.
• A domain name (optional but strongly recommended) — something like fastdl.yourdomain.com. You can run FastDL on a raw IP but HTTPS is cleaner with a domain.
• Ports 80 and 443 open on the firewall and with your host.
• About 2–10 GB of disk space depending on how many custom maps you run.

05 // Install nginx

On Ubuntu 22.04 or 24.04, install nginx from the official repo:

sudo apt update
sudo apt install -y nginx
sudo systemctl enable --now nginx

Verify it’s running:

curl -I http://localhost
# Expected: HTTP/1.1 200 OK
# Server: nginx/1.24.0 (Ubuntu)

If you have ufw enabled, open HTTP and HTTPS:

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw reload

06 // Set Up the FastDL Directory Structure

Create the web root and the game-specific subdirectories. The subdirectory name after /var/www/fastdl/ must match the game’s mod name — tf for TF2, csgo for CS:GO (still used by CS2 legacy paths for some assets), cstrike for CS:S, garrysmod for GMod.

sudo mkdir -p /var/www/fastdl/tf/maps
sudo mkdir -p /var/www/fastdl/tf/materials
sudo mkdir -p /var/www/fastdl/tf/models
sudo mkdir -p /var/www/fastdl/tf/sound
sudo mkdir -p /var/www/fastdl/tf/particles
sudo mkdir -p /var/www/fastdl/tf/resource

The critical folders for a TF2 server:

07 // Configure nginx for FastDL

Create a dedicated server block for FastDL at /etc/nginx/sites-available/fastdl:

sudo nano /etc/nginx/sites-available/fastdl

Paste this config (replace fastdl.yourdomain.com with your actual domain, or remove the server_name line to serve on any hostname):

server {
    listen 80;
    listen [::]:80;
    server_name fastdl.yourdomain.com;

    root /var/www/fastdl;
    index index.html;

    # Disable directory listing for security
    autoindex off;

    # Long cache: map files never change after upload
    location / {
        add_header Cache-Control "public, max-age=31536000, immutable";
        try_files $uri =404;
    }

    # Serve .bz2 as raw binary (Valve client decompresses itself)
    location ~ \.bz2$ {
        types { }
        default_type application/octet-stream;
        add_header Cache-Control "public, max-age=31536000, immutable";
    }

    # Block hidden files and backups
    location ~ /\. { deny all; }
    location ~ ~$ { deny all; }

    access_log /var/log/nginx/fastdl_access.log;
    error_log  /var/log/nginx/fastdl_error.log;
}

Enable the site and reload nginx:

sudo ln -s /etc/nginx/sites-available/fastdl /etc/nginx/sites-enabled/
sudo nginx -t        # must say "syntax is ok" and "test is successful"
sudo systemctl reload nginx

08 // Enable HTTPS with Let’s Encrypt (Free SSL)

Modern Source engine clients work with both HTTP and HTTPS FastDL URLs, and HTTPS avoids mixed-content warnings on Source 2 games. Certbot gives you a free cert in 90 seconds:

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d fastdl.yourdomain.com \
    --non-interactive --agree-tos -m admin@yourdomain.com --redirect

Certbot will edit your nginx config to add HTTPS listeners and automatically renew the cert every 60 days via a systemd timer. Verify:

sudo systemctl list-timers | grep certbot
curl -I https://fastdl.yourdomain.com
# Expected: HTTP/2 200

09 // Configure Your Game Server (server.cfg)

Open your game server’s server.cfg file:

• TF2: /home/tf2/serverfiles/tf/cfg/server.cfg
• CS2: /home/cs2/serverfiles/game/csgo/cfg/server.cfg
• CS:S: /home/css/serverfiles/cstrike/cfg/server.cfg
• GMod: /home/gmod/serverfiles/garrysmod/cfg/server.cfg

Add these lines (anywhere in the file):

// FastDL configuration
sv_downloadurl "https://fastdl.yourdomain.com/tf/"
sv_allowdownload 1
sv_allowupload 0
net_maxfilesize 64

// Force clients to use FastDL for custom content (TF2/CS:S specific)
sv_consistency 1
sv_pure 0

Explanation of each line:

Restart the game server to apply.

10 // Mirror Your Game Server’s Content to FastDL

The initial mirror copies every custom asset your game server currently has to /var/www/fastdl/. Run this as root (adjust source paths to match your install):

# TF2 example — adjust paths for your setup
SRC=/home/tf2/serverfiles/tf
DST=/var/www/fastdl/tf

sudo rsync -av --include='*/' \
    --include='*.bsp' --include='*.vtf' --include='*.vmt' \
    --include='*.mdl' --include='*.vvd' --include='*.vtx' --include='*.phy' \
    --include='*.wav' --include='*.mp3' --include='*.pcf' \
    --exclude='*' \
    $SRC/maps/      $DST/maps/
sudo rsync -av $SRC/materials/ $DST/materials/
sudo rsync -av $SRC/models/    $DST/models/
sudo rsync -av $SRC/sound/     $DST/sound/
sudo rsync -av $SRC/particles/ $DST/particles/

For CS2, the source paths look like /home/cs2/serverfiles/game/csgo/maps/ and you’ll typically only mirror the maps/ folder since custom textures are rarely pushed on Source 2.

11 // Compress Maps with bzip2

Compressing .bsp files with bzip2 cuts download size by 40–70% depending on map content. The game client handles decompression automatically — players never see the .bz2 files.

Compress all maps in one command (the -k flag keeps the uncompressed originals as a fallback):

cd /var/www/fastdl/tf/maps
sudo bzip2 -k *.bsp

If you have hundreds of maps, parallelize with xargs:

find /var/www/fastdl/tf/maps -name '*.bsp' -print0 | \
    xargs -0 -n 1 -P 4 bzip2 -k

Verify the result:

ls -lh /var/www/fastdl/tf/maps/ | head -10
# -rw-r--r-- 1 root root  42M cp_orange_x3.bsp
# -rw-r--r-- 1 root root  14M cp_orange_x3.bsp.bz2   ← this is what players download

12 // Set Correct Permissions

This is where most FastDL setups silently fail with HTTP 403. nginx runs as the www-data user on Debian/Ubuntu and needs read access to every file plus execute on every directory in the path.

sudo chown -R www-data:www-data /var/www/fastdl
sudo find /var/www/fastdl -type d -exec chmod 755 {} \;
sudo find /var/www/fastdl -type f -exec chmod 644 {} \;

Test that nginx can serve a file:

curl -I https://fastdl.yourdomain.com/tf/maps/cp_orange_x3.bsp.bz2
# Expected: HTTP/2 200
#           content-type: application/octet-stream
#           content-length: 14532198

13 // Automate the Sync with cron or systemd

Manually running rsync and bzip2 every time you add a map is fine for day one. By week two you will forget, a player will join mid-rotation, hit a missing map, and disconnect. Automate it.

Save this sync script to /usr/local/bin/fastdl-sync.sh:

sudo nano /usr/local/bin/fastdl-sync.sh

#!/usr/bin/env bash
# fastdl-sync.sh — mirror game server content to FastDL, compress maps
set -euo pipefail

SRC="/home/tf2/serverfiles/tf"
DST="/var/www/fastdl/tf"
LOG="/var/log/fastdl-sync.log"

echo "[$(date -Is)] sync start" >> "$LOG"

# 1. Mirror maps + selected asset types
rsync -a --delete \
    --include='*/' \
    --include='*.bsp' --include='*.nav' --include='*.txt' \
    --exclude='*' \
    "$SRC/maps/" "$DST/maps/"

rsync -a "$SRC/materials/" "$DST/materials/" 2>/dev/null || true
rsync -a "$SRC/models/"    "$DST/models/"    2>/dev/null || true
rsync -a "$SRC/sound/"     "$DST/sound/"     2>/dev/null || true
rsync -a "$SRC/particles/" "$DST/particles/" 2>/dev/null || true

# 2. Compress any new .bsp that doesn't already have a .bz2 sibling
find "$DST/maps" -name '*.bsp' -print0 | while IFS= read -r -d '' bsp; do
    if [ ! -f "${bsp}.bz2" ] || [ "$bsp" -nt "${bsp}.bz2" ]; then
        bzip2 -kf "$bsp"
        echo "[$(date -Is)] compressed: $(basename "$bsp")" >> "$LOG"
    fi
done

# 3. Remove .bz2 files whose .bsp source has been deleted
find "$DST/maps" -name '*.bsp.bz2' -print0 | while IFS= read -r -d '' bz; do
    bsp="${bz%.bz2}"
    [ -f "$bsp" ] || rm -f "$bz"
done

# 4. Fix permissions (nginx must be able to read)
chown -R www-data:www-data "$DST"
find "$DST" -type d -exec chmod 755 {} \;
find "$DST" -type f -exec chmod 644 {} \;

echo "[$(date -Is)] sync done" >> "$LOG"

Make it executable and run it once to confirm:

sudo chmod +x /usr/local/bin/fastdl-sync.sh
sudo /usr/local/bin/fastdl-sync.sh
sudo tail /var/log/fastdl-sync.log

Option A — cron (simplest): run every 15 minutes:

sudo crontab -e
# Add this line:
*/15 * * * * /usr/local/bin/fastdl-sync.sh

Option B — systemd timer (cleaner, better logs): create /etc/systemd/system/fastdl-sync.service:

[Unit]
Description=FastDL content sync

[Service]
Type=oneshot
ExecStart=/usr/local/bin/fastdl-sync.sh

And /etc/systemd/system/fastdl-sync.timer:

[Unit]
Description=Run FastDL sync every 15 minutes

[Timer]
OnBootSec=2min
OnUnitActiveSec=15min
Persistent=true

[Install]
WantedBy=timers.target

sudo systemctl daemon-reload
sudo systemctl enable --now fastdl-sync.timer
sudo systemctl list-timers | grep fastdl

14 // Verify FastDL Is Working (HTTP Layer)

Before you trust FastDL in production, hit it like a client would:

# 1. Pick a known map on your server and check it exists
ls -lh /var/www/fastdl/tf/maps/ | head -5

# 2. Fetch the .bz2 with curl — must return 200 and application/octet-stream
curl -I https://fastdl.yourdomain.com/tf/maps/cp_orange_x3.bsp.bz2

# 3. Fetch a real binary and verify content-length matches the file
curl -o /tmp/test.bsp.bz2 https://fastdl.yourdomain.com/tf/maps/cp_orange_x3.bsp.bz2
ls -lh /tmp/test.bsp.bz2
bzip2 -t /tmp/test.bsp.bz2 && echo "bz2 archive OK"

# 4. Check nginx access log to confirm the hit
sudo tail -5 /var/log/nginx/fastdl_access.log

If all four checks pass, the HTTP layer is solid. Now test from an actual game client.

15 // Verify FastDL In-Game

On your game server console (or via RCON), change map to something custom:

changelevel cp_orange_x3

Then join the server from a client that does not already have the map cached. You should see in your client console:

Downloading https://fastdl.yourdomain.com/tf/maps/cp_orange_x3.bsp.bz2
Receiving file cp_orange_x3.bsp.bz2 (14.2MB)
100% complete
Extracting cp_orange_x3.bsp.bz2...

If instead you see Downloading cp_orange_x3.bsp from server with a slow progress bar, FastDL is not being used. Jump to the troubleshooting table at the end of this guide.

16 // CS2 — What’s Different in Source 2

CS2 changed the FastDL landscape significantly. For most community servers, Steam Workshop handles map distribution entirely — you set host_workshop_map 3070788321 (or whatever Workshop ID) and clients download directly from Steam’s CDN at whatever speed Valve serves. No FastDL needed.

Where FastDL still matters for CS2:

The paths are slightly different on CS2 — assets live under game/csgo/ rather than directly under the mod folder, and maps are .vpk archives instead of loose .bsp:

# CS2 FastDL directory layout
/var/www/fastdl/csgo/maps/de_privatemap.vpk
/var/www/fastdl/csgo/maps/de_privatemap.vpk.bz2

# server.cfg
sv_downloadurl "https://fastdl.yourdomain.com/csgo/"
sv_allowdownload 1

17 // Bandwidth & When to Move Off the Same VPS

A same-VPS FastDL setup works great until it doesn’t. Here’s when to consider offloading:

The signals that you need to migrate:

• VPS bandwidth allowance getting close to monthly cap
• CPU spikes on nginx during peak hours (usually map change on multiple servers at once)
• Players in a distant region complaining about slow downloads
• You want to keep the game server alive through DDoS attacks on the web port

18 // Migrating to Cloudflare R2 (Optional Upgrade Path)

If you outgrow same-VPS FastDL, the cheapest cloud upgrade is Cloudflare R2 — zero egress fees, about €0.015 per GB stored. The migration is a one-line change once you’ve synced the files:

1. Create an R2 bucket called yourserver-fastdl in the Cloudflare dashboard.
2. Enable public access and attach a custom domain: fastdl.yourdomain.com.
3. Use rclone to sync your existing FastDL folder up:

   rclone config    # set up remote "r2" with R2 credentials
   rclone sync /var/www/fastdl r2:yourserver-fastdl --progress

4. Update server.cfg: sv_downloadurl "https://fastdl.yourdomain.com/tf/" — if you kept the domain the same, that’s the only change.
5. Adjust your cron script to also sync to R2:

   rclone sync /var/www/fastdl r2:yourserver-fastdl --exclude '*.bsp'

   (Skipping the uncompressed .bsp saves storage cost since players only fetch .bz2.)

19 // The Mistakes Nobody Warns You About

After walking dozens of admins through FastDL setup, almost every failure collapses into one of these seven root causes:

20 // Full Troubleshooting Table

21 // Hardware Recommendations for FastDL + Game Server Together

Running FastDL on the same VPS as your game server is cheap and reliable, but the VPS needs enough headroom to handle both. Here are the honest tiers:

22 // Next Steps

• Secure the panel — Pterodactyl setup guide covers SSH hardening, 2FA, and fail2ban.
• Build the TF2 server — TF2 community server setup with SourceMod, custom configs, and FastDL linked in.
• Build the CS2 server — CS2 server setup with Workshop maps, SourceTV, and troubleshooting.
• Panel vs CLI — LinuxGSM offers a simpler CLI workflow if you don’t want a web panel.
• Compare hosts — Hostinger vs Contabo vs Hetzner vs OVH for Source engine game server use cases.