php-wasm

PHP in WebAssembly, npm not required.

📦 Current Packages

php-wasm, php-cgi-wasm, php-cli-wasm, php-dbg-wasm, and php-wasm-builder are published separately.
Published runtimes currently cover PHP 8.0 through 8.5, depending on the package and entrypoint.
php-wasm, php-cgi-wasm, and php-dbg-wasm currently default to PHP 8.4; php-cli-wasm currently defaults to PHP 8.3. Pass version explicitly when your asset filenames need to line up.
Runtime-loadable libraries are available for gd, iconv, intl, libxml, xml, dom, simplexml, yaml, zip, mbstring, openssl, phar, sqlite, and zlib.
Vrzno, pdo_cfd1, and pdo_pglite are maintained as separate packages.

Install the packages you need:

$ npm i php-wasm
$ npm i php-cgi-wasm
$ npm i php-cli-wasm
$ npm i php-dbg-wasm
$ npm i php-wasm-builder

☀️ Examples

[React + php-web/php-cgi-worker demo]

Drupal Demo

CakePHP Demo

CodeIgniter Demo

Laravel Demo

Laminas Demo

Code Editor

🎩 Introducing php-cgi-wasm!

php-cgi-wasm runs PHP in web-server mode, similar to Apache or nginx. Running within a Service Worker, it can intercept and respond to HTTP requests just like a normal web server. This means the browser can simply navigate to a URL and let PHP generate the page, with AJAX and other in-page requests still flowing over normal HTTP.

Install the php-cgi-wasm package

$ npm install php-cgi-wasm

Example Service Worker:

import { PhpCgiWorker } from "php-cgi-wasm/PhpCgiWorker";

// Spawn the PHP-CGI binary
const php = new PhpCgiWorker({
    prefix:  '/php-wasm',
    docroot: '/persist/www',
    types: {
        jpg:  'image/jpeg',
        jpeg: 'image/jpeg',
        gif:  'image/gif',
        png:  'image/png',
        svg:  'image/svg+xml',
    }
});

// Set up the event handlers
self.addEventListener('install',  event => php.handleInstallEvent(event));
self.addEventListener('activate', event => php.handleActivateEvent(event));
self.addEventListener('fetch',    event => php.handleFetchEvent(event));
self.addEventListener('message',  event => php.handleMessageEvent(event));

You can see examples of php-cgi-wasm running in a service worker and Node.js in demo-web/src/cgi-worker.mjs and demo-node/index.mjs respectively.

Note: php-cgi-wasm and php-wasm are separate packages. One embeds PHP directly into your JavaScript runtime; the other runs in CGI mode, like PHP under Apache or nginx.

You can find documentation specific to php-cgi-wasm here.

🛠️ Install & Use

Install php-wasm with npm:

$ npm install php-wasm

Include the module:

ESM

import { PhpWeb } from 'php-wasm/PhpWeb.mjs';
const php = new PhpWeb;

From a CDN:

Note: This does not require npm.

jsdelivr

const { PhpWeb } = await import('https://cdn.jsdelivr.net/npm/php-wasm/PhpWeb.mjs');
const php = new PhpWeb;

unpkg

const { PhpWeb } = await import('https://unpkg.com/php-wasm/PhpWeb.mjs');
const php = new PhpWeb;

Pre-Packaged Static Assets:

If you're using a bundler, use the vendor's documentation to move the versioned .wasm file that matches the runtime, PHP version, and module format you import. For example:

node_modules/php-wasm/php8.4-web.mjs.wasm
node_modules/php-wasm/php8.4-worker.mjs.wasm # ONLY if you're running the standard build in a worker

For php-cgi-wasm:

node_modules/php-cgi-wasm/php8.4-cgi-node.mjs.wasm # ONLY if you're running the CGI build in Node.js
node_modules/php-cgi-wasm/php8.4-cgi-worker.mjs.wasm # ONLY if you're running the CGI build in a worker

If you import a different runtime version, copy the matching php8.x-*.mjs.wasm file as well.

Core Node runtimes support both ESM and CommonJS.

For 0.1.0, use the published entrypoints across the runtime packages:

php-wasm/PhpNode
php-cgi-wasm/PhpCgiNode
php-cli-wasm/PhpCliNode
php-dbg-wasm/PhpDbgNode

Browser/runtime helper entrypoints such as PhpWeb and php-tags remain ESM-first.

🍎 Quickstart

Inline PHP

Include the php-tags module from a CDN:

<script async type = "module" src = "https://cdn.jsdelivr.net/npm/php-wasm/php-tags.mjs"></script>

And run some PHP right in the page!

<script type = "text/php" data-stdout = "#output">
<?php phpinfo();
</script>
<div id = "output"></div>

Inline PHP can use standard input, output, and error with data- attributes. Set each attribute value to a selector that matches the corresponding element.

<script async type = "module" src = "https://cdn.jsdelivr.net/npm/php-wasm/php-tags.mjs"></script>

<script id = "input" type = "text/plain">Hello, world!</script>

<script type = "text/php" data-stdin = "#input" data-stdout = "#output" data-stderr = "#error">
    <?php echo file_get_contents('php://stdin');
</script>

<div id = "output"></div>
<div id = "error"></div>

The src attribute can be used on <script type = "text/php"> tags, as well as their input elements. For example:

<html>
    <head>
        <script async type = "module" src = "https://cdn.jsdelivr.net/npm/php-wasm/php-tags.mjs"></script>
        <script id = "input" src = "/test-input.json" type = "text/json"></script>
        <script type = "text/php" src = "/test.php" data-stdin = "#input" data-stdout = "#output" data-stderr = "#error"></script>
    </head>
    <body>
        <div id = "output"></div>
        <div id = "error"></div>
    </body>
</html>

CDNs

JSDelivr

<script async type = "module" src = "https://cdn.jsdelivr.net/npm/php-wasm/php-tags.mjs"></script>

Unpkg

<script async type = "module" src = "https://unpkg.com/php-wasm/php-tags.mjs"></script>

🥤 Running PHP & Taking Output

Create a PHP instance:

const { PhpWeb } = await import('https://cdn.jsdelivr.net/npm/php-wasm/PhpWeb.mjs');
const php = new PhpWeb;

Add your output listeners:

// Listen to STDOUT
php.addEventListener('output', (event) => {
    console.log(event.detail);
});

// Listen to STDERR
php.addEventListener('error', (event) => {
    console.log(event.detail);
});

Provide some input data on STDIN if you need to:

php.inputString('This is a string of data provided on STDIN.');

... then run some PHP!

const exitCode = await php.run('<?php echo "Hello, world!";');

Dynamic Extensions in Static Pages

Dynamic extensions can be loaded in static webpages like so:

<script async type = "module" src = "https://cdn.jsdelivr.net/npm/php-wasm/php-tags.mjs"></script>

<script type = "text/php" data-stdout = "#output" data-stderr = "#error" data-libs = '[
  {"url": "https://unpkg.com/php-wasm-yaml/php8.4-yaml.so", "ini": true},
  {"url": "https://unpkg.com/php-wasm-yaml/libyaml.so", "ini": false}
]'><?php
  print yaml_emit([1,2,3,"string",["k1" => "value", "k2" => "value2", "k3" => "value3"],"now" => date("Y-m-d h:i:s")]);
</script>

The example above assumes the default php-tags runtime version (8.4). If you set data-version to something else, update the php8.x-*.so filenames to match.

⚙️ Configuration

You can pass in the ini property to the constructor to add lines to /php.ini:

const php = new PhpWeb({ini: `
    date.timezone=${Intl.DateTimeFormat().resolvedOptions().timeZone}
    tidy.clean_output=1
    expose_php=0
`});

The /config/php.ini and /preload/php.ini files will also be loaded, if they exist. Neither of these files will be created if they do not exist. They're left completely up to the programmer to create & populate.

Options like the following may appear in these files. See the PHP docs for the full list.

[php]
date.timezone=UTC
tidy.clean_output=1
expose_php=0

CGI Configuration

When running in CGI mode, php will look for a php.ini file in the document root directory, and load it along with the files listed above.

Writing an INI for multiple PHP versions

PHP will replace strings in INI files in the form ${ENVIRONMENT_VARIABLE} with the env value of ENVIRONMENT_VARIABLE. The PHP_VERSION environment variable is available to allow loading of the extension compatible with the currently running version of PHP:

[php]
extension=php${PHP_VERSION}-phar.so

Remember to correctly escape the $ if you're supplying the INI from JavaScript with backticks:

const php = new PhpWeb({ini: `
    extension=php\${PHP_VERSION}-phar.so
    date.timezone=${Intl.DateTimeFormat().resolvedOptions().timeZone}
`});

🔌 Extensions

Loading extensions at runtime

The following extensions may be loaded at runtime. This allows the shared extensions and their dependencies to be cached, reused, and selected a la carte for each application.

gd (https://www.npmjs.com/package/php-wasm-gd)
iconv (https://www.npmjs.com/package/php-wasm-iconv)
intl (https://www.npmjs.com/package/php-wasm-intl)
libxml (https://www.npmjs.com/package/php-wasm-libxml)
xml (https://www.npmjs.com/package/php-wasm-xml)
dom (https://www.npmjs.com/package/php-wasm-dom)
simplexml (https://www.npmjs.com/package/php-wasm-simplexml)
yaml (https://www.npmjs.com/package/php-wasm-libyaml)
zip (https://www.npmjs.com/package/php-wasm-libzip)
mbstring (https://www.npmjs.com/package/php-wasm-mbstring)
openssl (https://www.npmjs.com/package/php-wasm-openssl)
phar (https://www.npmjs.com/package/php-wasm-phar)
sqlite (https://www.npmjs.com/package/php-wasm-sqlite)
pdo-sqlite (https://www.npmjs.com/package/php-wasm-sqlite)
zlib (https://www.npmjs.com/package/php-wasm-zlib)

There are two ways to load extensions at runtime, using the dl() function or php.ini.

<?php
dl('php8.4-xml.so');
dl('php8.4-dom.so');

Or pass a sharedLibs array to the constructor from JavaScript to auto-generate an INI file that loads your extensions:

const php = new PhpWeb({sharedLibs: [
    `php8.4-xml.so`,
    `php8.4-dom.so`,
]});

Keep the runtime version and the shared-library filenames in sync when you target something other than the default build:

const version = '8.4';

const php = new PhpWeb({version, sharedLibs: [
    `php${version}-xml.so`,
    `php${version}-dom.so`,
]});

Dynamic Extensions from Remote Servers:

You can also load extensions from remote servers with URLs:

const version = '8.4';
const php = new PhpWeb({version, sharedLibs: [`https://unpkg.com/php-wasm-phar/php${version}-phar.so`]});

The above is actually shorthand for the following code. Passing ini: true will automatically load the extension via /php.ini, passing ini: false will wait for a call to dl() to do the lookup.

const php = new PhpWeb({sharedLibs: [
    {
        name: `php8.4-phar.so`,
        url:  `https://unpkg.com/php-wasm-phar/php8.4-phar.so`,
        ini:  true,
    }
]});

Strings starting with /, ./, http:// or https:// will be treated as URLs:

const php = new PhpWeb({sharedLibs: [
    `./php8.4-phar.so`
]});

Some extensions require supporting libraries. You can provide URLs for those as sharedLibs as well, just pass ini: false:

(name is implied to be the last section of the URL here.)

const php = new PhpWeb({sharedLibs: [
    { url: 'https://unpkg.com/php-wasm-sqlite/php8.4-sqlite.so', ini: true  },
    { url: 'https://unpkg.com/php-wasm-sqlite/libsqlite3.so',    ini: false },
]});

Loading Dynamic Extensions as JS Modules

Dynamic extensions can be loaded as modules. As long as the main file of the module defines the getLibs and getFiles methods, extensions may be loaded like so:

new PhpNode({sharedLibs:[ await import('php-wasm-intl') ]})

Dynamic extensions can also be loaded as modules from any static HTTP server with an ESM directory structure.

// This will load both libsqlite3.so and php8.4-sqlite.so:
const php = new PhpWeb({sharedLibs: [ await import('https://cdn.jsdelivr.net/npm/php-wasm-sqlite') ]});

This notation is not available for Service Workers, since they do not yet support dynamic import() in this workflow.

The extension helper JS packages shown above are ESM-only. If you need to bypass those helper packages, pass the extension assets manually instead of importing the helper package:

import { PhpNode } from 'php-wasm/PhpNode';

const php = new PhpNode({
    sharedLibs: [
        {
            name: 'php8.4-intl.so',
            url: new URL('./vendor/php8.4-intl.so', import.meta.url).href,
            ini: true,
        },
        { name: 'libicuuc.so',   url: new URL('./vendor/libicuuc.so', import.meta.url).href },
        { name: 'libicutu.so',   url: new URL('./vendor/libicutu.so', import.meta.url).href },
        { name: 'libicutest.so', url: new URL('./vendor/libicutest.so', import.meta.url).href },
        { name: 'libicuio.so',   url: new URL('./vendor/libicuio.so', import.meta.url).href },
        { name: 'libicui18n.so', url: new URL('./vendor/libicui18n.so', import.meta.url).href },
        { name: 'libicudata.so', url: new URL('./vendor/libicudata.so', import.meta.url).href },
    ],
    files: [
        {
            name: 'icudt72l.dat',
            parent: '/preload/',
            url: new URL('./vendor/icudt72l.dat', import.meta.url).href,
        },
    ],
});

When you manage extension assets this way, build mode matters:

dynamic: provide the extension .so plus any support libraries and preload files it needs
shared: provide only the extra support libraries and preload files the runtime still needs
static: do not inject the extension assets again

Compiling extensions

Extensions may be compiled as dynamic, shared, or static. See Custom Builds for more information on compiling php-wasm.

dynamic - these extensions may be loaded selectively at runtime.
shared - these extensions will always be loaded at startup and can be cached and reused.
static - these extensions will be built directly into the main wasm binary (may cause a huge filesize).

📦 Loading Files

Loading single files at runtime

When spawning a new instance of PHP, a files array can be provided to be loaded into the filesystem. For example, the php-intl extension requires us to load icudt72l.dat into the /preload directory.

const sharedLibs = [`https://unpkg.com/php-wasm-intl/php\${PHP_VERSION}-intl.so`];

const files = [
    {
        name: 'icudt72l.dat',
        parent: '/preload/',
        url: 'https://unpkg.com/php-wasm-intl/icudt72l.dat'
    }
];

const php = new PhpWeb({sharedLibs, files});

Preloaded FS

Use the PRELOAD_ASSETS key in your .php-wasm-rc file to define a list of files and directories to include by default.

The files and directories will be collected into a single directory. Individual files & directories will appear in the top level, while directories will maintain their internal structure.

These files & directories will be available under /preload in the final package, packaged into the .data file that is built along with the .wasm file.

PRELOAD_ASSETS='/path/to/file.txt /some/directory /path/to/other_file.txt /some/other/directory'

locateFile

You can provide the locateFile option to php-wasm as a callback to map the names of files to URLs where they're loaded from. undefined can be returned as a fallback to default.

You can use this if your static assets are served from a different directory than your JavaScript.

This applies to .wasm files, shared libraries, single files and preloaded FS packages in .data files.

const php = new PhpWeb({locateFile: filename => `/my/static/path/${filename}`});

💾 Persistent Storage (IDBFS & NodeFS)

IDBFS (Web & Worker)

To use IDBFS in PhpWeb, pass a persist object with a mountPath key.

mountPath will be used as the path to the persistent directory within the PHP environment.

const { PhpWeb } = await import('https://cdn.jsdelivr.net/npm/php-wasm/PhpWeb.mjs');

const php = new PhpWeb({persist: {mountPath: '/persist'}});

NodeFS (Node.js Only)

To use NodeFS in PhpNode, pass a persist object with mountPath and localPath keys.

localPath will be used as the path to the HOST directory to expose to PHP. mountPath will be used as the path to the persistent directory within the PHP environment.

import path from 'node:path';
import { PhpNode } from 'php-wasm/PhpNode';

const php = new PhpNode({
    persist: {
        mountPath: '/persist',
        localPath: path.join(process.cwd(), 'persist'),
    }
});

📁 Filesystem Operations

Filesystem Methods

The following EmscriptenFS methods are exposed via the php object:

Note: If you're using php-web in conjunction with php-cgi-worker to work on the filesystem, you'll need to refresh the filesystem in the worker. You can do that with the following call using msg-bus (see below).

// Tell the worker that the FS has been updated
await sendMessage('refresh');

php.analyzePath

Get information about a file or directory.

await php.analyzePath(path);

php.readdir

Get a list of files and folders in a directory.

await php.readdir(path);

php.readFile

Get the content of a file as a Uint8Array by default, or optionally as utf-8.

await php.readFile(path);

await php.readFile(path, {encoding: 'utf8'});

php.stat

Get information about a file or directory.

await php.stat(path);

php.mkdir

Create a directory.

await php.mkdir(path);

php.rmdir

Delete a directory (must be empty).

await php.rmdir(path);

php.unlink

Delete a file.

await php.unlink(path);

php.rename

Rename a file or directory.

await php.rename(path, newPath);

php.writeFile

Create a new file. Content should be supplied as a Uint8Array, or optionally as a string of text.

await php.writeFile(path, data);

await php.writeFile(path, data, {encoding: 'utf8'});

Transactions

Web and Worker only!

The web and worker builds use navigator.locks.request to request a lock named php-wasm-fs-lock before performing filesystem operations. This ensures multiple tabs and the service worker can interact with the filesystem without overwriting each other's work. Before any filesystem operation takes place, the entire FS is loaded from IDBFS, and before the lock is released, the entire FS is loaded back into IDBFS.

The operations are enqueued asynchronously, so if multiple requests are generated before one transaction closes, they will be batched automatically. This also applies to multiple requests generated before the lock is acquired. There is generally no need to take explicit control of FS mirroring.

To suppress this behavior and take explicit control of FS mirroring, you can pass the {autoTransaction: false} option to the constructor. Doing this requires you to call php.startTransaction() before any FS operations take place, and then php.commitTransaction() when you're done. Using this incorrectly may leave your filesystem in a corrupted state.

php.startTransaction

await php.startTransaction();

php.commitTransaction

await php.commitTransaction();

msg-bus

There is a msg-bus module supplied by php-cgi-wasm as a helper to communicate with PHP running inside a worker. The module exposes two functions: sendMessageFor and onMessage.

This lets you simply await the result of calls to filesystem methods (see above) on the service worker:

const result = await sendMessage(methodName, [param, param, param]);

onMessage & sendMessageFor

Use onMessage as an event handler for message events coming from the Service Worker.
Use sendMessageFor to GENERATE A FUNCTION that you can use to send messages to your service worker.

import { onMessage, sendMessageFor } from 'php-cgi-wasm/msg-bus';

const SERVICE_WORKER_SCRIPT_URL = '/cgi-worker.mjs';

navigator.serviceWorker.register(SERVICE_WORKER_SCRIPT_URL);

navigator.serviceWorker.addEventListener('message', onMessage);

const sendMessage = sendMessageFor(SERVICE_WORKER_SCRIPT_URL);

const result = await sendMessage(methodName, [param, param, param]);

php.handleMessageEvent

Once you've got the above set up, use php.handleMessageEvent to handle the message events on the service worker:

self.addEventListener('message',  event => php.handleMessageEvent(event));

🏗️ Custom Builds

To use the in-place builder, first install php-wasm-builder globally:

Requires docker, docker-compose, coreutils, wget, & make.

$ npm install -g php-wasm-builder

Create the build environment (can be run from anywhere):

$ php-wasm-builder image

Optionally clean up files from a previous build:

$ php-wasm-builder clean

Build for web

Then navigate to the directory you want the files to be built in, and run php-wasm-builder build

$ cd ~/my-project
$ php-wasm-builder build
# php-wasm-builder build web
#  "web" is the default here

Build for node

$ cd ~/my-project
$ php-wasm-builder build node

ESM Modules:

Build ESM modules with:

$ php-wasm-builder build web mjs
$ php-wasm-builder build node mjs

CGI Modules:

Build CGI modules with:

$ php-wasm-builder build web cgi mjs
$ php-wasm-builder build worker cgi mjs

This will build the package inside the current directory (or in PHP_DIST_DIR, see below for more info.)

.php-wasm-rc

You can also create a .php-wasm-rc file in this directory to customize the build.

# Select a PHP version
PHP_VERSION=8.4

# Build the package to a directory other than the current one (RELATIVE path)
PHP_DIST_DIR=./public

# Build the extensions to a directory other than the current one (RELATIVE path)
PHP_ASSET_DIR=./public


# Build the cgi package to a directory other than the current one (RELATIVE path)
PHP_CGI_DIST_DIR=./public

# Build the cgi package's extensions to a directory other than the current one (RELATIVE path)
PHP_CGI_ASSET_DIR=./public

# Space separated list of files/directories (ABSOLUTE paths)
# to be included under the /preload directory in the final build.
PRELOAD_ASSETS=~/my-project/php-scripts ~/other-dir/example.php

# Memory to start the instance with, before growth
INITIAL_MEMORY=2048MB

# Build with assertions enabled
ASSERTIONS=0

# Select the optimization level
OPTIMIZE=3

# Build with extensions
WITH_GD=1
WITH_LIBPNG=1
WITH_LIBJPEG=1
WITH_FREETYPE=1

Options

The following options may appear in .php-wasm-rc.

PHP_VERSION

8.0|8.1|8.2|8.3|8.4|8.5

PHP_DIST_DIR

This is the directory where JavaScript and wasm files will be built, relative to the current directory.

PHP_ASSET_DIR

This is the directory where preload .data / .dat files and other supporting assets will be built, relative to the current directory. Shared libraries and side modules remain in their owning packages. Defaults to PHP_DIST_DIR.

OPTIMIZE

0|1|2|3

The optimization level to use while compiling.

SUB_OPTIMIZE

The optimization level to use while compiling libraries. Defaults to OPTIMIZE.

PRELOAD_ASSETS

A list of absolute paths to files & directories to build to the /preload directory. Will produce a .data file.

ASSERTIONS

0|1

Build with/without assertions.

Extensions

As stated above, extensions may be compiled as dynamic, shared, or static.

dynamic - these extensions may be loaded selectively at runtime.
shared - these extensions will always be loaded at startup and can be cached and reused.
static - these extensions will be built directly into the main wasm binary (may cause a huge filesize).

(defaults provided below in bold)

The following options are available for building static PHP extensions:

WITH_BCMATH    # [0, 1] Enabled by default
WITH_CALENDAR  # [0, 1] Enabled by default
WITH_CTYPE     # [0, 1] Enabled by default
WITH_EXIF      # [0, 1] Enabled by default
WITH_FILTER    # [0, 1] Enabled by default
WITH_TOKENIZER # [0, 1] Enabled by default
WITH_VRZNO     # [0, 1] Enabled by default
WITH_WAITLINE  # [0, 1] Disabled by default in raw custom builds

The following extensions may be compiled as static, shared, or dynamic:

WITH_PHAR      # [0, 1, static, dynamic]
WITH_LIBXML    # [0, 1, static, shared]
WITH_ICONV     # [0, 1, static, shared, dynamic]
WITH_SQLITE    # [0, 1, static, shared, dynamic]

WITH_LIBZIP    # [0, 1, static, shared, dynamic]
WITH_ZLIB      # [0, 1, static, shared, dynamic]

WITH_GD        # [0, 1, static, shared, dynamic]
WITH_LIBPNG    # [0, 1, static, shared]
WITH_FREETYPE  # [0, 1, static, shared]
WITH_LIBJPEG   # [0, 1, static, shared]

WITH_YAML      # [0, 1, static, shared, dynamic]
WITH_TIDY      # [0, 1, static, shared, dynamic]
WITH_MBSTRING  # [0, 1, static, dynamic]
WITH_ONIGURUMA # [0, 1, static, shared]
WITH_OPENSSL   # [0, 1, shared, dynamic]
WITH_INTL      # [0, 1, static, shared, dynamic]

WITH_PHAR

static|dynamic

When compiled as a dynamic extension, this will produce the extension file php8.x-phar.so.

WITH_LIBXML

static|shared

The libxml extension itself must be statically compiled, but libxml2 may be loaded as a shared library.

When compiled as a shared library, it will produce the library libxml2.so.

WITH_LIBZIP

static|shared|dynamic

When compiled as a dynamic extension, this will produce the extension php8.x-zip.so.

When compiled as a dynamic or shared extension, it will produce the library libzip.so.

This extension depends on zlib.

WITH_ICONV

static|shared|dynamic

When compiled as a dynamic extension, this will produce the extension php8.x-iconv.so.

When compiled as a dynamic or shared extension, it will produce the library libiconv.so.

WITH_SQLITE

static|shared|dynamic

When compiled as a dynamic extension, this will produce the extensions php8.x-sqlite.so and php8.x-pdo-sqlite.so.

When compiled as a dynamic or shared extension, it will produce the library libsqlite3.so.

WITH_GD

static|dynamic

This extension makes use of freetype, libjpeg, libpng, and zlib.

When compiled as a dynamic extension, this will produce the extension php8.x-gd.so.

WITH_LIBPNG

static|shared

When compiled as a shared library, this will produce the library libpng.so.

If WITH_GD is dynamic, then loading will be deferred until after gd is loaded.

WITH_FREETYPE

static|shared

When compiled as a shared library, this will produce the library libfreetype.so.

If WITH_GD is dynamic, then loading will be deferred until after gd is loaded.

WITH_LIBJPEG

static|shared

When compiled as a shared library, this will produce the library libjpeg.so.

If WITH_GD is dynamic, then loading will be deferred until after gd is loaded.

WITH_ZLIB

static|shared|dynamic

When compiled as a dynamic extension, this will produce the extension php8.x-zlib.so.

When compiled as a dynamic or shared extension, it will produce the library libz.so.

WITH_YAML

static|shared|dynamic

When compiled as a dynamic extension, this will produce the extension php8.x-yaml.so.

When compiled as a dynamic or shared extension, it will produce the library libyaml.so.

WITH_TIDY

static|shared|dynamic

When compiled as a dynamic extension, this will produce the extension php8.x-tidy.so.

When compiled as a dynamic or shared extension, it will produce the library libtidy.so.

WITH_MBSTRING

static|dynamic

When compiled as a dynamic extension, this will produce the extension php8.x-mbstring.so.

WITH_ONIGURUMA

static|shared|dynamic

Support library for mbstring.

When compiled as a dynamic or shared library, this will produce the library libonig.so.

If WITH_MBSTRING is dynamic, then loading will be deferred until after mbstring is loaded.

WITH_OPENSSL

shared|dynamic

When compiled as a dynamic extension, this will produce the extension php8.x-openssl.so.

When compiled as a dynamic or shared extension, it will produce the libraries libssl.so & libcrypto.so.

WITH_INTL

static|shared|dynamic

When compiled as a dynamic or shared extension, this will produce the extension php8.x-intl.so and the following libraries:

libicuuc.so
libicutu.so
libicutest.so
libicuio.so
libicui18n.so
libicudata.so
icudt72l.dat

php-wasm-builder commands

php-wasm-builder build

Use this to build a custom version of php-wasm. It's recommended to build into an empty directory using a .php-wasm-rc file.

npx php-wasm-builder build

php-wasm-builder image

This will build the docker container used to build php-wasm.

npx php-wasm-builder image

php-wasm-builder copy-assets

This will scan the current package's node_modules directory for supporting data files, and copy them to PHP_ASSET_DIR.

You can use this with .php-wasm-rc to copy assets even if you're not using a custom build.

npx php-wasm-builder copy-assets

php-wasm-builder build-assets

Similar to copy-assets, but will build the supporting asset files described by .php-wasm-rc, then copy them to PHP_ASSET_DIR.

You can use this with .php-wasm-rc to copy assets even if you're not using a custom build.

npx php-wasm-builder build-assets

php-wasm-builder clean

Clear cached build resources.

npx php-wasm-builder clean

php-wasm-builder deep-clean

Clear out all downloaded dependencies and start from scratch.

npx php-wasm-builder deep-clean

php-wasm-builder help

Print the help text for a given command

npx php-wasm-builder help COMMAND

🤝 php-wasm started as a fork of oraoto/PIB...

The repository pib-legacy was created to preserve the original state of the project.

https://github.com/oraoto/pib

https://github.com/seanmorris/pib-legacy

🍻 Licensed under the Apache License, Version 2.0

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

http://www.apache.org/licenses/LICENSE-2.0

Special thanks to Alex Haussmann

Name		Name	Last commit message	Last commit date
Latest commit History 1,360 Commits
.cache		.cache
.circleci		.circleci
.cloudflare/pages		.cloudflare/pages
.github		.github
bin		bin
demo-node		demo-node
demo-web		demo-web
docs		docs
githooks		githooks
lib		lib
packages		packages
patch		patch
source		source
test		test
third_party		third_party
.babelrc		.babelrc
.editorconfig		.editorconfig
.gitattributes		.gitattributes
.gitignore		.gitignore
.npmignore		.npmignore
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
LICENSE-GPL		LICENSE-GPL
Makefile		Makefile
NOTICE		NOTICE
README.md		README.md
compress-package.sh		compress-package.sh
docker-compose.yml		docker-compose.yml
emscripten-builder.dockerfile		emscripten-builder.dockerfile
eslint.config.mjs		eslint.config.mjs
hash-wasms.sh		hash-wasms.sh
ico.ans		ico.ans
info.mak		info.mak
jsconfig.json		jsconfig.json
make		make
overlay-workspace-from-actions.sh		overlay-workspace-from-actions.sh
package-lock.json		package-lock.json
package.json		package.json
php.mk		php.mk
playwright.config.mjs		playwright.config.mjs
publish-packages.sh		publish-packages.sh
remap-sourcemap.sh		remap-sourcemap.sh
serve-demo-web-from-actions.sh		serve-demo-web-from-actions.sh
set-versions.sh		set-versions.sh

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

php-wasm

📦 Current Packages

☀️ Examples

[React + php-web/php-cgi-worker demo]

🎩 Introducing php-cgi-wasm!

Install the php-cgi-wasm package

Example Service Worker:

🛠️ Install & Use

ESM

From a CDN:

jsdelivr

unpkg

Pre-Packaged Static Assets:

🍎 Quickstart

Inline PHP

CDNs

JSDelivr

Unpkg

🥤 Running PHP & Taking Output

Dynamic Extensions in Static Pages

⚙️ Configuration

CGI Configuration

Writing an INI for multiple PHP versions

🔌 Extensions

Loading extensions at runtime

Dynamic Extensions from Remote Servers:

Loading Dynamic Extensions as JS Modules

Compiling extensions

📦 Loading Files

Loading single files at runtime

Preloaded FS

locateFile

💾 Persistent Storage (IDBFS & NodeFS)

IDBFS (Web & Worker)

NodeFS (Node.js Only)

📁 Filesystem Operations

Filesystem Methods

php.analyzePath

php.readdir

php.readFile

php.stat

php.mkdir

php.rmdir

php.unlink

php.rename

php.writeFile

Transactions

php.startTransaction

php.commitTransaction

msg-bus

onMessage & sendMessageFor

php.handleMessageEvent

🏗️ Custom Builds

Build for web

Build for node

ESM Modules:

CGI Modules:

.php-wasm-rc

Options

PHP_VERSION

PHP_DIST_DIR

PHP_ASSET_DIR

OPTIMIZE

SUB_OPTIMIZE

PRELOAD_ASSETS

ASSERTIONS

Extensions

WITH_PHAR

WITH_LIBXML

WITH_LIBZIP

WITH_ICONV

WITH_SQLITE

WITH_GD

WITH_LIBPNG

WITH_FREETYPE

Packages