Build Online (using GitHub Actions)

Use GitHub Action to easily build a statically compiled PHP, and at the same time define the extensions to be compiled by yourself.

  1. Fork me.
  2. Go to the Actions of the project and select CI.
  3. Select Run workflow, fill in the PHP version you want to compile, the target type, and the list of extensions. (extensions comma separated, e.g. bcmath,curl,mbstring)
  4. After waiting for about a period of time, enter the corresponding task and get Artifacts.

If you enable debug, all logs will be output at build time, including compiled logs, for troubleshooting.

Build Locally (using SPC binary)

This project provides a binary file of static-php-cli: spc. You can use spc binary instead of installing any runtime like golang app. Currently, the platforms supported by spc binary are Linux and macOS.

Download from self-hosted nightly builds using commands below:

# Download from self-hosted nightly builds (sync with main branch)
# For Linux x86_64
curl -o spc
# For Linux aarch64
curl -o spc
# macOS x86_64 (Intel)
curl -o spc
# macOS aarch64 (Apple)
curl -o spc
# Windows (x86_64, win10 build 17063 or later)
curl.exe -o spc.exe

# Add execute perm (Linux and macOS only)
chmod +x ./spc

# Run (Linux and macOS)
./spc --version
# Run (Windows powershell)
.\spc.exe --version

Self-hosted spc is built by GitHub Actions, you can also download from Actions artifacts here.

Build Locally (using git source)

# just clone me!
git clone

If you have not installed php on your system, we recommend that you use the built-in setup-runtime to install PHP and Composer automatically.

cd static-php-cli
chmod +x bin/setup-runtime
# it will download static php (from self-hosted server) and composer (from getcomposer)
# initialize composer deps
bin/composer install
# chmod
chmod +x bin/spc
bin/spc --version

Start Building PHP

Basic usage for building php with some extensions:

If you are using the packaged standalone spc binary, you need to replace bin/spc with ./spc or .\spc.exe in the following commands.

# Check system tool dependencies, auto-fix them if possible
./bin/spc doctor --auto-fix

# fetch all libraries
./bin/spc download --all
# only fetch necessary sources by needed extensions (recommended)
./bin/spc download --for-extensions="openssl,pcntl,mbstring,pdo_sqlite"
# download different PHP version (--with-php=x.y, recommend 7.3 ~ 8.3)
./bin/spc download --for-extensions="openssl,curl,mbstring" --with-php=8.1

# with bcmath,openssl,tokenizer,sqlite3,pdo_sqlite,ftp,curl extension, build both CLI and phpmicro SAPI
./bin/spc build "bcmath,openssl,tokenizer,sqlite3,pdo_sqlite,ftp,curl" --build-cli --build-micro
# build thread-safe (ZTS) version (--enable-zts)
./bin/spc build "curl,phar" --enable-zts --build-cli
# build, pack executable with UPX (--with-upx-pack) (reduce binary size for 30~50%)
./bin/spc build "curl,phar" --enable-zts --build-cli --with-upx-pack

Now we support cli, micro, fpm and embed SAPI. You can use one or more of the following parameters to specify the compiled SAPI:

  • --build-cli: build static cli executable
  • --build-micro: build static phpmicro self-extracted executable
  • --build-fpm: build static fpm binary
  • --build-embed: build embed (libphp)
  • --build-all: build all

If anything goes wrong, use --debug option to display full terminal output:

./bin/spc build "openssl,pcntl,mbstring" --debug --build-all
./bin/spc download --all --debug

Different SAPI Usage

Use cli

php-cli is a single static binary, you can use it like normal php installed on your system.

When using the parameter --build-cli or --build-all, the final compilation result will output a binary file named ./php, which can be distributed and used directly. This file will be located in the directory buildroot/bin/, copy it out for use.

cd buildroot/bin/
./php -v                # check version
./php -m                # check extensions
./php your_code.php     # run your php code
./php your_project.phar # run your phar (project archive)

Use micro

phpmicro is a SelF-extracted eXecutable SAPI module, provided by phpmicro project. But this project is using a fork of phpmicro, because we need to add some features to it. It can put php runtime and your source code together.

When using the parameter --build-all or --build-micro, the final compilation result will output a file named ./micro.sfx, which needs to be used with your PHP source code like code.php. This file will be located in the path buildroot/bin/micro.sfx, simply copy it out for use.

Prepare your project source code, which can be a single PHP file or a Phar file, for use.

echo "<?php echo 'Hello world' . PHP_EOL;" > code.php
cat micro.sfx code.php > single-app && chmod +x single-app

If you package a PHAR file, just replace code.php with the phar file path. You can use box-project/box to package your CLI project as Phar, It is then combined with phpmicro to produce a standalone executable binary.

# Use the micro.sfx generated by static-php-cli to combine,
bin/spc micro:combine my-app.phar
# or you can directly use the cat command to combine them.
cat buildroot/bin/micro.sfx my-app.phar > my-app && chmod +x my-app

# Use micro:combine combination to inject INI options into the binary.
bin/spc micro:combine my-app.phar -I "memory_limit=4G" -I "disable_functions=system" --output my-app-2

In some cases, PHAR files may not run in a micro environment. Overall, micro is not production ready.

Use fpm

When using the parameter --build-all or --build-fpm, the final compilation result will output a file named ./php-fpm, This file will be located in the path buildroot/bin/, simply copy it out for use.

In common Linux distributions and macOS systems, the package manager will automatically generate a default fpm configuration file after installing php-fpm. Because php-fpm must specify a configuration file before running, the php-fpm compiled by this project will not have any configuration files, so you need to write php-fpm.conf and pool.conf configuration files yourself.

Specifying php-fpm.conf can use the command parameter -y, for example: ./php-fpm -y php-fpm.conf.

Use embed

When using the project parameters --build-embed or --build-all, the final compilation result will output a libphp.a, php-config and a series of header files, stored in buildroot/. You can introduce them in your other projects.

If you know embed SAPI, you should know how to use it. You may require the introduction of other libraries during compilation, you can use buildroot/bin/php-config to obtain the compile-time configuration.

For an advanced example of how to use this feature, take a look at how to use it to build a static version of FrankenPHP.

Was this helpful?

0 / 0

发表回复 0