Self-hosted image compressor — run Scalir with Docker

Option A — Docker Compose Recommended

The quickest way to run Scalir as a Docker image compressor: clone the repo and bring up the scalir service (the tool). Nginx serves it on port 8080 — point your reverse proxy at that.

# 1. Clone
git clone https://github.com/therealshxd/scalir
cd scalir

# 2. Start the tool (builds the image on first run, ~60 s)
docker compose up -d scalir

# Tool is now running at http://localhost:8080

The compose file also defines a scalir-landing service (port 8081) that serves the full site. Run docker compose up -d scalir-landing for that, or omit the service name to start both.

To update to a newer version, pull the latest code and rebuild:

git pull
docker compose up -d --build

To run on a different port, edit docker-compose.yml and change "8080:80" to your preferred port before starting.

Option B — Dokploy, Coolify & similar panels

If you manage your server with a Docker-based deployment panel, Scalir works out of the box since it ships a Dockerfile. The steps below are for Dokploy but are nearly identical for Coolify, Caprover, and others — just look for "new app from Git".

Steps (Dokploy)

1. In your Dokploy dashboard → Create Project → Create Service → Application (not Compose).
2. Under Provider, connect GitHub and select the repo (or paste the public repo URL), branch main.
3. Set Build Type to Dockerfile. Note this is a separate card below the Git source section — not inside the GitHub tab. Then set the Docker File path to Dockerfile for the tool (use Dockerfile.landing for the full site).
4. Set Container port to 80.
5. Add a domain under the Domains tab and enable HTTPS.
6. Hit Deploy. Dokploy builds the image and starts the container.

Updating manually: after new commits land on main, hit Redeploy in the dashboard — Dokploy pulls the latest commit and rebuilds the image. Note that tracking is by branch, not git tags.

Auto-deploy on push (optional)

To rebuild automatically on every push to main, set up a webhook one of two ways:

1. GitHub App (cleanest): Dokploy → Settings → Git → GitHub → install the GitHub App and grant it access to your repo. Then open the app → Provider, confirm branch main, and toggle Auto Deploy → On. Dokploy creates and manages the webhook for you — nothing to do on the GitHub side.
2. Manual webhook: on the app, toggle Auto Deploy → On and copy the Webhook URL it shows. In GitHub → repo Settings → Webhooks → Add webhook, paste it as the Payload URL, set Content type to application/json, choose Just the push event, and save.

Verify with a test push: the GitHub webhook's Recent Deliveries should show a 200, and a new build should appear under the app's Deployments tab.

After any deploy: hard-refresh the site (Ctrl/Cmd-Shift-R). Scalir is a PWA, so the service worker can serve cached assets until it updates.

Coolify: same flow — New Resource → Public Repository → paste the repo URL → Build Pack: Dockerfile → Dockerfile location Dockerfile (or Dockerfile.landing) → set port to 80 → Deploy.

Option C — Manual build

Build the static files yourself and serve them from any host — nginx, Caddy, Apache, Netlify, Cloudflare Pages, etc.

Requirements: Node.js 20+

# 1. Clone and install
git clone https://github.com/therealshxd/scalir
cd scalir
npm install

# 2. Build the standalone app
npm run build:app
# Output: dist-app/

# 3. Serve with any static server, e.g.:
npx serve dist-app

Copy dist-app/ to your web server's document root. No server-side logic needed — it's a fully static site.

nginx example — minimal config to serve from /opt/scalir:

server {
    listen 80;
    root /opt/scalir;
    index index.html;
    location / {
        try_files $uri $uri/ /index.html;
    }
}