Website · Documentation · Get in Touch · Report a Bug

Docker-based WordPress development and publishing platform with two modes:

• Local Mode — Full-featured local WordPress development tool (like Local by Flywheel / Laragon) with multi-PHP, multi-DB support, and a wpl CLI
• Agency Mode — Demo hosting platform that spins up temporary WordPress sites pre-loaded with your plugins/themes, auto-deleted after expiration

Each site runs in its own Docker container with a choice of SQLite, MySQL, or MariaDB, routed through Traefik with automatic subdomain assignment.

User clicks "Launch Demo"
  → API creates a Docker container with your product pre-installed
  → Traefik auto-routes a unique subdomain to the container
  → WordPress auto-installs via entrypoint script
  → User gets a working WordPress site in ~10 seconds
  → Site auto-deletes after expiration (default: 1 hour)

• Instant provisioning — Pre-built Docker images with plugins baked in (~10s launch time)
• Full isolation — Each site is a separate container, no shared databases
• 3 database engines — SQLite (fastest), MySQL 8.4, or MariaDB 11 per site
• 3 PHP versions — PHP 8.1, 8.2, or 8.3 selectable per site
• Per-site PHP config — Tune memory_limit, upload size, execution time, and toggle extensions (Redis, Xdebug, etc.) per site — live, no restart needed
• wpl CLI — Global command to start/stop services, manage sites, run WP-CLI, and more
• Persistent data — Local mode sites survive container restarts via Docker volumes
• Auto-cleanup — Agency mode sites auto-expire and get removed
• One-click admin login — Auto-login URLs for instant WP admin access
• Email testing — Built-in Mailpit catches all outgoing emails locally
• Multi-product — Host demos for multiple products from a single installation
• Wildcard subdomains — Each site gets a unique URL like coral-sunset-7x3k.localhost
• Site password protection — Optional basic auth on frontend only, admin only, or entire site for private previews
• Export site as ZIP — Download wp-content + DB dump as tar.gz to migrate demo customizations
• Webhook notifications — HMAC-SHA256 signed HTTP POST on site.created/expired/deleted with admin UI for management
• Site Health Monitoring — Real-time container CPU, memory, network stats with color-coded dashboard
• Scheduled Site Launch — Schedule sites to launch automatically at a future time (up to 7 days)
• Modern dashboard — React SPA with real-time provisioning progress

wp-launcher/
├── docker-compose.yml          # Infrastructure (Traefik + API + Dashboard)
├── .env.example                # Environment configuration
├── install.sh                  # One-click VPS installer
├── install-local.sh            # Local mode installer
├── bin/wpl                     # Global CLI command
├── packages/
│   ├── api/                    # Management API (Express/TypeScript)
│   ├── provisioner/            # Docker container management service
│   └── dashboard/              # React SPA (Vite)
├── wordpress/                  # Custom WP Docker image
│   ├── Dockerfile
│   ├── entrypoint.sh           # Auto-installs WP + activates plugins
│   ├── wp-config-docker.php
│   └── mu-plugins/             # Admin restrictions, branding & auto-login
├── products/                   # Product configs (agency mode)
│   └── _default.json
├── templates/                  # Template configs (local mode)
│   └── starter.json
├── product-assets/             # Local plugins/themes per product
│   └── my-product/
│       └── plugins/
├── traefik/                    # Reverse proxy config
├── scripts/
│   ├── setup.sh                # Initial setup script
│   └── build-wp-image.sh       # Builds product Docker images
└── guides/                     # Documentation
    ├── getting-started.md
    ├── creating-products.md
    ├── working-with-wordpress-files.md  # Edit themes/plugins in Docker
    ├── adding-product-images.md
    ├── vps-deployment.md
    ├── cloudflare-dns-setup.md
    └── upgrading.md

Use WP Launcher as a local WordPress development tool — like Local by Flywheel or Laragon, but Docker-based with multi-PHP support.

git clone https://github.com/msrbuilds/wp-launcher.git
cd wp-launcher
bash install-local.sh

That's it. The installer will:

1. Check for Docker & Docker Compose
2. Generate .env with local mode defaults
3. Build WordPress images for PHP 8.1, 8.2, and 8.3
4. Install the wpl CLI command globally
5. Start all services
6. Open http://localhost in your browser

What you get:

• No authentication, no site limits, no WordPress restrictions (file mods, updates, cron all enabled)
• Choose PHP version (8.1 / 8.2 / 8.3), database engine (MySQL / MariaDB / SQLite), and admin credentials per site
• Sites at http://{subdomain}.localhost (works in Chrome, Firefox, Edge — no hosts file needed)
• Persistent site data via Docker volumes (survives restarts)
• Built-in email testing via Mailpit at http://localhost:8025
• Global wpl CLI command (see CLI Reference below)

Host temporary WordPress demo sites for your products — with auth, site limits, auto-expiration, and admin restrictions.

Run the one-click installer on a fresh Ubuntu VPS:

curl -sSL https://scripts.msrbuilds.com/wplauncher/install.sh | bash

This will:

1. Install Docker & Docker Compose
2. Clone the repository
3. Prompt for your domain, email, and SMTP settings
4. Generate secure secrets
5. Configure Traefik with automatic Let's Encrypt SSL
6. Build all Docker images
7. Start all services

For a detailed step-by-step guide, see guides/vps-deployment.md.

Prerequisites: Docker Desktop, Node.js 18+, Git Bash (Windows) or any Unix shell.

git clone https://github.com/msrbuilds/wp-launcher.git
cd wp-launcher
cp .env.example .env
# Edit .env with your settings (see Configuration section)

Build the WordPress images:

bash scripts/build-wp-image.sh

Add your first product — create products/my-product.json:

{
  "id": "my-product",
  "name": "My Awesome Plugin",
  "plugins": {
    "preinstall": [
      { "source": "wordpress.org", "slug": "my-plugin", "activate": true }
    ],
    "remove": ["hello", "akismet"]
  },
  "demo": {
    "default_expiration": "1h",
    "max_concurrent_sites": 5,
    "admin_user": "demo",
    "landing_page": "/wp-admin/admin.php?page=my-plugin"
  },
  "restrictions": {
    "disable_file_mods": true,
    "blocked_capabilities": [
      "install_plugins", "install_themes",
      "edit_plugins", "edit_themes", "update_core"
    ]
  },
  "database": "sqlite",
  "docker": {
    "image": "wp-launcher/my-product:latest"
  },
  "branding": {
    "banner_text": "Demo site — expires in {time_remaining}.",
    "description": "Try My Awesome Plugin in a live WordPress environment."
  }
}

Build the product image and start:

bash scripts/build-wp-image.sh my-product
docker compose up -d

Visit http://localhost — the dashboard is ready.

Each JSON file in products/ defines a demo product. The filename must match the id field (e.g., my-product.json → "id": "my-product").

Three ways to include plugins:

{
  "plugins": {
    "preinstall": [
      { "source": "wordpress.org", "slug": "contact-form-7", "activate": true },
      { "source": "url", "url": "https://example.com/pro-plugin.zip", "activate": true },
      { "source": "local", "path": "product-assets/my-product/plugins/my-plugin.zip", "activate": true }
    ]
  }
}

Each site supports per-site PHP settings, configurable at creation time and live-updatable from the Sites dashboard (PHP button).

Configurable settings: memory_limit, upload_max_filesize, post_max_size, max_execution_time, max_input_vars, display_errors

Optional extensions (pre-installed in the Docker image, disabled by default):

PHP settings are written to /usr/local/etc/php/conf.d/99-wp-launcher.ini inside the container and applied via Apache graceful reload — no container restart required.

# 1. Create/edit the product JSON in products/
# 2. Build the Docker image and restart the API:
bash scripts/build-wp-image.sh my-product && docker compose restart api

The new product appears on the dashboard immediately.

In local mode, each site's wp-content directory is bind-mounted to your host at sites/{subdomain}/wp-content/. Edit plugins, themes, and files directly — no Docker commands needed.

# From the CLI
wpl code <subdomain>

# Or open manually
code sites/coral-sunset-7x3k/wp-content/plugins/my-plugin

The dashboard also has VS Code and Copy Path buttons on each site card.

wpl browse <subdomain>

The install-local.sh installer configures this automatically. For existing installations, add to .env:

SITES_HOST_PATH=/absolute/path/to/wp-launcher/sites

Then rebuild: docker compose up -d --build api provisioner

wpl wp <subdomain> plugin list      # Run WP-CLI
wpl shell <subdomain>               # Bash into container

For more methods and tips, see Working with WordPress Files Guide.

# Stop the dashboard container
docker compose stop dashboard

# Start Vite dev server (proxies API calls to the Docker API)
cd packages/dashboard && npm run dev

Dashboard available at http://localhost:4000 with instant hot reload.

Note: The Vite dev proxy reads API_PORT from the shell environment. If you changed API_PORT in .env, export it before starting the dev server:

export API_PORT=3800
npm run dev

The API runs inside Docker. After editing API source files:

docker compose build api && docker compose up -d api

The wpl command is installed globally by install-local.sh and works from any directory.

wpl start                            # Start all services
wpl stop                             # Stop all services
wpl restart                          # Restart all services
wpl rebuild                          # Rebuild and restart (after code changes)
wpl status                           # Show running containers
wpl logs [service]                   # Tail logs (all or specific service)
wpl sites                            # List active WordPress sites
wpl open                             # Open dashboard in browser
wpl open mail                        # Open Mailpit in browser
wpl open <subdomain>                 # Open a site in browser
wpl shell <subdomain>                # Bash into a site container
wpl wp <subdomain> plugin list       # Run WP-CLI in a site container
wpl code <subdomain>                 # Open site's wp-content in VS Code
wpl browse <subdomain>               # Open site's wp-content in file manager
wpl build:wp                         # Rebuild WordPress images (all PHP versions)
wpl dir                              # Print project directory path
wpl help                             # Show all commands

You can also use npm scripts from the project directory:

npm start          # Start services
npm stop           # Stop services
npm run rebuild    # Rebuild and restart
npm run status     # Show containers
npm run logs       # Tail logs

Each demo container uses approximately:

• RAM: ~100MB (WordPress + PHP + Apache + SQLite)
• Disk: ~200MB per container
• CPU: Minimal when idle

A server with 4GB RAM can comfortably run 20-30 concurrent demo sites.

MIT