Things you might have missed about the Playground project over the past few months

WordPress Playground is more than just the web version—it’s an entire ecosystem spanning from browser-based instances to command-line tools. The challenge of running WordPress in a browser has led to significant improvements for the WordPress ecosystem and the open web itself.

The project includes several supporting tools: JavaScript API, Playground CLI, PHP WASM, SQLite Database Integration pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party, and MySQLMySQL MySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com/. Parser. These improvements extend beyond WordPress and benefit the broader PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/preface.php. ecosystem.

Recent additions like XDebug support for PHP WASM #2408 will help all PHP applications, not just WordPress. Over the past few months, the team has made significant progress in network improvements, performance enhancement, feature parity, and developer experience.

• Network improvements,
• Performance enhancement,
• Feature Parity, and
• Developer experience.

Some new features you may have missed over the past months will be listed in this post.

Growth of the support environment

Many users know the WordPress Playground web instance, but Playground supports many more environments. The project has different layers beyond the web instance. WordPress Studio and Telex are two examples of projects that take advantage of Playground.

Looking at this from a developer perspective, the project consists of several packages that empower developers to use Playground in many areas.

Run WordPress and PHP applications in a Node.js environment

With php-wasm, it is possible to run PHP on your Node.js applications. This opens the door to several applications. Here you can see a quick demo of how to run PHP via WASM:

import express from 'express';
import { PHP } from '@php-wasm/universal';
import { loadNodeRuntime } from '@php-wasm/node';

const app = express();
const php = new PHP(await loadNodeRuntime('8.3'));

// PHP execution middleware
app.use('/php', async (req, res, next) => {
  try {
    const phpScript = req.query.script || 'index.php';
    const result = await php.runStream({
      scriptPath: `/www/${phpScript}`,
      env: {
        REQUEST_METHOD: req.method,
        QUERY_STRING: new URLSearchParams(req.query as Record).toString(),
        REQUEST_URI: req.url,
      },
    });

    res.send(await result.stdoutText);
  } catch (error) {
    next(error);
  }
});

app.listen(3000, () => {
  console.log('Server with PHP support running on port 3000');
});

Run WordPress/PHP applications in the Terminal with Playground CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress.

Playground CLI has reached a stable version. The CLI now contains a series of new features to help developers with testing and debugging. With this command, you can start a WordPress instance from the terminal:

cd my-plugin-or-theme-directory
npx @wp-playground/cli server --auto-mount

The --auto-mount parameter makes it operate like the deprecated wp-now, automatically mounting the current directory to the correct location: as a plugin, a theme, or a full WordPress install. That’s a convenient shortcut. Playground CLI also provides a comprehensive set of explicit configuration options for advanced development setups., 

Automated testing integration

PHP-WASM lets you run WordPress tests directly in Node.js. Without Docker, without VMs, without installing PHP, this provides developers with an alternative to traditional CI/CD workflows that require full server setups. By executing PHP directly in your JavaScriptJavaScript JavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/. test environment, you can write faster, more isolated tests that integrate seamlessly with modern testing frameworks.

Here’s an example showing how to integrate PHP WASM with Playwright:

import { test, expect } from '@playwright/test';
import { runCLI, RunCLIArgs, RunCLIServer } from '@wp-playground/cli';

test.describe('set-wordpress-language', () => {
  let cliServer: RunCLIServer;

  test.afterEach(async () => {
    if (cliServer) {
      await cliServer.server.close();
    }
  });

  test('should set WordPress site language to Portuguese (Brazil)', async () => {
    const expectedLanguage = 'pt_BR';

    cliServer = await runCLI({
      command: 'server',
      blueprint: {
        steps: [
          {
            step: 'setSiteLanguage',
            language: 'pt_BR',
          },
        ],
      },
    } as RunCLIArgs);

    // Create a PHP file to check the site language
    await cliServer.playground.writeFile(
      '/wordpress/check-language.php',
      ``
    );

    const response = await cliServer.playground.request({
      url: '/check-language.php',
      method: 'GET',
    });

    expect(response.httpStatusCode).toBe(200);
    expect(response.text.trim()).toBe(expectedLanguage);
  });
});

Help AI agents build your application

Seth Rubenstein recently showcased how Playground enables AI-assisted WordPress development. By integrating WP Playground CLI with GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ Copilot, they completed four low-priority features in one week—work that would normally take months due to the low priority. The key was allowing the AI agent to test its own code changes using Playground’s auto-mounting feature. The setup includes configuring firewall rules, package.json commands, and a AGENTS.md guide file. This shows how Playground bridges AI code generation with practical WordPress development.

More features coming soon

Some new features are in experimental mode, such as XDebug support and Blueprints V2. You can already test them and share your feedback with the team. Some of that feedback helped to expand the Playground’s use to other areas; for example, recently, the PHP Playground now supports installing Composer packages.

Performance improvements

The versatility of running WordPress anywhere comes with some challenges: a native environment is specialized for the specific use case, while running PHP and the entire WordPress environment on WASM introduces a few additional challenges. Some of those challenges are related to how we need to manage the data on the user side. At the same time, we can also use this to our advantage since it makes fetching data faster because all the data is in RAM.

Support for multiple Workers

Support for multiple workers is now available in Node.js Asyncify builds, enabling network requests to be handled concurrently across multiple, coexisting worker threads. This architectural improvement allows Playground to handle asynchronous operations more efficiently without blocking PHP execution. The multi-worker implementation was delivered through PR #2231 and PR #2317, which added file locking to prevent SQLite database corruption when multiple workers access the duplicate files. The experimental --experimental-multi-worker flag enables this feature in Playground CLI, with the default worker count set to CPU count minus one. PR #2446 created shared filesystem support so workers can see changes made by other workers.

OpCache is enabled by default

The most significant performance enhancement came in July 2025 when OpCache was enabled by default across all Playground instances. OpCache stores compiled PHP code in memory, eliminating repeated file reading and compilation—crucial for closing the performance gap with native environments.

WordPress 6.8 benchmark Results

Testing across WordPress pages showed consistent improvements:

• Average response time: 185ms → 108ms (42% faster)
• Best improvements: Feed endpoints and REST APIREST API The REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/. calls (48-54%)
• Homepage: 217ms → 148ms (33% improvement)

The OpCache implementation was achieved by adding the --enable-opcache argument to the PHP compilation process, enabled by default. The implementation includes shared-memory support via mmap() and forces Autoconf to recognize emulated shared anonymous memory. Tests show hit rates of approximately 90% or better after the cache warms up, significantly reducing the execution overhead that had been a major criticism of the WASM approach.

Networking Capabilities

In June 2025, Playground enabled network access by default, letting WordPress sites load data from other domains. While there are limitations around supported headers and file sizes, the update makes Playground far more practical for demos, plugin previews, and real-world testing scenarios.

Two major pull requests brought these improvements:

• PR #2076 replaced regular fetch() calls with fetchWithCorsProxy(). It first tries a direct fetch; if the browser blocks it, it retries via the proxy.
• PR #1926 added a custom TLS 1.2 layer that creates self-signed CA certificates trusted by PHP, runs full TLS handshakes, and uses window.crypto for encryption. This lets PHP functions like file_get_contents()  and curl make HTTPSHTTPS HTTPS is an acronym for Hyper Text Transfer Protocol Secure. HTTPS is the secure version of HTTP, the protocol over which data is sent between your browser and the website that you are connected to. The 'S' at the end of HTTPS stands for 'Secure'. It means all communications between your browser and the website are encrypted. This is especially helpful for protecting sensitive data like banking information. requests by performing a controlled man-in-the-middle bridge between PHP’s sockets and browser security rules.

Feature parity

A common misunderstanding about WordPress Playground is that it lacks critical features available in traditional WordPress environments. While some gaps remain, the team has made significant progress over the past year, adding support for key features that developers rely on.

WP Cron support

It’s not widely known, but WP Cron has been supported in Playground since November 2024. 

The fix was implemented in PR #2039, which simply removed the network bridge blockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. that had been disabling wp-cron.php requests. The original code path that caused performance issues was no longer running in the problematic Node.js environment after months of architectural improvements. Testing with the WP-Crontrol plugin confirmed that schedules now run as expected in both the web version and CLI version of Playground, with no observable slowdown in request processing.

This improvement directly addresses concerns about plugin compatibility, particularly for plugins that depend on WordPress’s scheduling system. Users who dismissed Playground months ago due to WP Cron limitations will find that this critical feature now works seamlessly.

SQLite Compatibility Issues

SQLite development became a major focus in 2025, with 30 merged pull requests addressing SQL compatibility in WordPress Playground. The breakthrough came from replacing regex-based translation with a complete MySQL parser—one of the most comprehensive parsers outside of mysql-server itself—that generates an Abstract Syntax Tree (AST).

The new architecture includes a pure PHP MySQL lexer, a comprehensive SQL parser, a MySQL-to-SQLite translator with extensive dialect handling, and a MySQL Information Schema emulator. This enables support for complex features like UNION operators, SHOW and DESCRIBE statements, INFORMATION_SCHEMA tables, and table administration commands.

The next-generation SQLite Database Integration plugin demonstrates remarkable progress, passing 99% of WordPress unit tests. The Information Schema emulator plays a big role here, since it provides the MySQL metadata tables that many plugins need. Thanks to that, most WordPress plugins—and database tools such as phpMyAdmin and Adminer—work smoothly in Playground’s SQLite environment.

Additional Feature Parity Improvements

PHP 8.3 became the default version for playground.wordpress.net and Playground CLI in July 2025. This gives you access to the latest language features and performance improvements. XDebug support is now available experimentally, giving developers proper debugging tools for PHP applications running in WASM. We’re working on making this feature stable and will announce the official release soon.

Dynamic XDebug loading was introduced for PHP-wasm Node JSPI, followed by experimental devtools support in PHP-wasm CLI and Playground CLI. The XDebug bridge experience was improved in September 2025 with preloading of source files. We’re also working to integrate with Chrome DevTools, which will let you debug PHP in Playground using the same familiar tools you use for JavaScript—including breakpoints, step-through debugging, and variable inspection right in your browser.

Network access limitations have been greatly reduced. Previously, Playground instances required manual setup to access external resources. As of June 2025, networking is enabled by default on playground.wordpress.net, allowing plugins that fetch remote data, connect to APIs, or download assets to function without additional setup. Documentation was updated to reflect this change.

This improvement makes Playground suitable for showing e-commerce plugins, social media integrations, and other network-dependent functionality. Leave in the comments each feature you are excited about.

Props to @akirk, @zieladam, @bpayton, @janjakes,  and @pbh for contributing to and/or providing feedback on this article.