Fellyph Cintra 5:03 pm on April 7, 2026

Migrating WordPress Playground Documentation to WordPress.org

At the beginning of 2026, the Playground team received a community request to migrate the official WordPress Playground documentation to the standard Handbook format on WordPress.orgWordPress.org The community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/.

The current documentation uses Docusaurus, which offers several features that speed up our work, including a built-in internationalization system, component libraries, reusable components with MDX, and a configuration file for integrating external features like Kapa.ai.

Moving to the official handbook It establishes Playground as a coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. WordPress project and provides a familiar documentation structure for our users. However, migrating from our current setup presents a few unique technical challenges. Here is an update on our progress, the challenges we are navigating, and our roadmap for the migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies..

The Challenge: Docusaurus vs. Handbook Formatting

To migrate to the WordPress.org Handbook format, we need to adapt our existing Docusaurus-specific components to work within the Handbook’s script rendering. Similar to the GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ project, we have created a JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. file mapping all pages to be included in the new handbook.

We are taking two approaches to handle the markdown conversion:

Duplication of the current format to a Handbook-friendly format.
Migrating essential components to alternatives that can be natively rendered by the Handbook scripts.

The selected approach was the second, using alternative components compatible with both platforms, which avoids duplicating work and keeps both versions online.

Progress Report: What We’ve Completed & What’s in Progress

Anchor Links & IDs (Done): We have removed all hardcoded IDs used for internal page linking, as the Handbook handles this natively.
Asset Loading (Done): Docusaurus uses dynamic pointing for asset folders (like images). We have updated our approach to point directly to the raw files hosted on 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 by the repository owner. https://github.com/, ensuring images render correctly without issue.
MDX Fragments (In Review): Playground docs heavily utilize MDX fragments (reusable snippets of code/text used across multiple pages). We have created a PR to adapt these fragments for an inline structure, and it is currently under review.
Callout Components (To Do): Docusaurus components for Warnings, Info, and Tips currently do not render in the Handbook. We need to create alternatives for these to ensure important points of attention are still highlighted for the user.
SEO & Open Graph Data (To Do): We need to double-check our Open Graph data (logos, descriptions, titles). Currently, every page has a headerHeader The header of your site is typically the first thing people will experience. The masthead or header art located across the top of your page is part of the look and feel of your website. It can influence a visitor’s opinion about your content and you/ your organization’s brand. It may also look different on different screen sizes. defining its title and summary. We need to collaborate with the Handbook team to ensure these are being parsed dynamically for optimal SEO.

The Migration Roadmap

To ensure a smooth transition, we have broken the migration into three distinct phases:

Phase 1: The English Migration

Our immediate priority is to get the core English documentation published in the WordPress.org Handbook. During this time, both documents will be live; the English version will, in the meantime, redirect to the Handbook once the migration is complete.

Phase 2: Internationalization (i18n)

Playground boasts a highly localized user base, with over 220 pages translated into languages including Portuguese, Japanese, Spanish, French, Gujarati, Bengali, and Tagalog.

Because Handbook support for translations is still evolving, we have established a fallback strategy:

We will define a set of pages eligible for translation and publishing in the new handbook, something similar to what we have in the current docs. At a minimum, the first “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.” of introductory pages must be translated; otherwise, the user will be redirected to the English version, the current behavior with Docusaurus.
Fallback Plan: Until Phase 2 is complete, we will keep the Docusaurus site live strictly as a fallback for international users. English traffic will be redirected to WordPress.org, while translated content will remain on Docusaurus until it can be safely migrated.

At WordCampWordCamp WordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Asia, @fellyph will be present and will lead the Contributor table for WordPress. One of the themes of the contributor dayContributor Day Contributor Days are standalone days, frequently held before or after WordCamps but they can also happen at any time. They are events where people get together to work on various areas of https://make.wordpress.org/ There are many teams that people can participate in, each with a different focus. https://2017.us.wordcamp.org/contributor-day/ https://make.wordpress.org/support/handbook/getting-started/getting-started-at-a-contributor-day/ for Playground will be the migration of the docs and the discussion of a solution for internationalization.

Phase 3: The “Ask AI” Feature

Late last year, we introduced the “Ask AI” button (powered by Kapa.ai) to help users find immediate answers to specific questions and blueprint rendering errors. This feature has been incredibly useful, but migrating it requires careful consideration.

Testing: The Kapa.ai team proposed to use the solution on the .org account. But this should be discussed with the Docs team to move forward.
Privacy Considerations: Because user queries are stored in the Kapa.ai dashboard, we need to have a detailed discussion with the documentation team regarding privacy policies before implementing this on the official .org domain.

Next Steps

The playground team will continue working on unblocking Phase 1 by resolving the remaining component and SEO metadata issues. We will also be reaching out to the Handbook and Docs teams to clarify our i18n redirect rules and the future of the Ask AI implementation.

Fellyph Cintra 9:42 am on April 2, 2026
Tags: agent-skills, ai ( 2 ), playground ( 4 )

Teach your coding agent to write WordPress Playground Blueprints

The new blueprint agent skill teaches your coding agent the Playground Blueprint schema, which defines valid property names, resource types, and step sequencing. No more pluginZipFile instead of pluginData. No more runPHP steps missing require '/wordpress/wp-load.php'.

Install it once, and your agent generates valid Blueprint JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. with a high success rate, and the best part of it all with natural language. That is perfect for testing new ideas, finding edge cases in your Plugins and Themes, and creating demos from your projects.

What the blueprint skill does

The skill is a structured Markdown reference that your coding agent loads into its context. It covers:

Every top-level property: landingPage, preferredVersions, features, steps, shorthands (login, plugins, siteOptions, constants)
All resource types: wordpress.org/plugins, wordpress.org/themes, url, git:directory, literal:directory, bundled
Step reference: installPlugin, writeFile, writeFiles, runPHP, wp-cli, runSql, and more
Common mistakes: a table of pitfalls the agent checks against before generating output
Blueprint bundles: self-contained packages with bundled resources

The agent reads this reference before writing any Blueprint. Instead of guessing property names, it follows the documented schema.

How to install the skill

For a quick install, use the npx skills CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. to add the blueprint skill to your project:

npx skills add wordpress/agent-skills --skill blueprint

Or install manually by cloning the agent-skills repository and running the build script:

git clone https://github.com/WordPress/agent-skills.git
cd agent-skills
node shared/scripts/skillpack-build.mjs --clean
node shared/scripts/skillpack-install.mjs --dest=../your-wp-project --targets=claude,gemini,codex,cursor,vscode

The skill works with Claude Code, Gemini CLI, 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 by the repository owner. https://github.com/ Copilot, Cursor, and Codex.

Five examples

Each example below shows a prompt you give your agent and the Blueprint it produces. These are real-world scenarios where the blueprint skill prevents common errors.

1. Quick development environment

Prompt:

Create a Blueprint that sets up a development environment with
debug mode, the Developer plugin, and landing on the admin dashboard.

Generated Blueprint:

{
  "$schema": "https://playground.wordpress.net/blueprint-schema.json",
  "landingPage": "/wp-admin/",
  "preferredVersions": { "php": "8.3", "wp": "latest" },
  "features": { "networking": true },
  "constants": {
    "WP_DEBUG": true,
    "WP_DEBUG_LOG": true
  },
  "login": true,
  "plugins": ["developer"],
  "steps": []
}

Notice how the agent uses the constants shorthand instead of a defineWpConfigConsts step, and login: true instead of a separate login step. The skill teaches agents to pick shorthands for simple cases and explicit steps when order matters.

WordPress Admin panel showing the Developer plugin enabled via blueprint

2. 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. from a GitHub branch

Prompt:

Write a Blueprint that installs my plugin from the feature/checkout-v2
branch on GitHub and activates it.

Generated Blueprint:

{
  "$schema": "https://playground.wordpress.net/blueprint-schema.json",
  "landingPage": "/wp-admin/plugins.php",
  "preferredVersions": { "php": "8.3", "wp": "latest" },
  "steps": [
    { "step": "login" },
    {
      "step": "installPlugin",
      "pluginData": {
        "resource": "git:directory",
        "url": "https://github.com/your-org/your-plugin",
        "ref": "feature/checkout-v2",
        "refType": "branch",
        "path": "/"
      },
      "options": { "activate": true }
    }
  ]
}

Without the skill, agents commonly omit refType, which causes git:directory to fail for branch names. The skill’s common mistakes table flags this explicitly: “Omitting refType with branch/tag ref — required; only HEAD works without it.”

3. WooCommerce store with sample products

Prompt:

Create a Blueprint for a WooCommerce store with 5 sample products
across 2 categories, running on PHP 8.2.

Generated Blueprint:

{
  "$schema": "https://playground.wordpress.net/blueprint-schema.json",
  "landingPage": "/shop/",
  "preferredVersions": { "php": "8.2", "wp": "latest" },
  "features": { "networking": true },
  "steps": [
    { "step": "login" },
    {
      "step": "installPlugin",
      "pluginData": { "resource": "wordpress.org/plugins", "slug": "woocommerce" },
      "options": { "activate": true }
    },
    {
      "step": "runPHP",
      "code": "<?php\nrequire '/wordpress/wp-load.php';\n\n// Create categories\n$cat_clothing = wp_insert_term('Clothing', 'product_cat');\n$cat_accessories = wp_insert_term('Accessories', 'product_cat');\n\n$products = [\n  ['T-Shirt', 29.99, $cat_clothing['term_id']],\n  ['Hoodie', 59.99, $cat_clothing['term_id']],\n  ['Jeans', 49.99, $cat_clothing['term_id']],\n  ['Watch', 89.99, $cat_accessories['term_id']],\n  ['Backpack', 39.99, $cat_accessories['term_id']]\n];\n\nforeach ($products as [$title, $price, $cat_id]) {\n  $post_id = wp_insert_post([\n    'post_title' => $title,\n    'post_type' => 'product',\n    'post_status' => 'publish'\n  ]);\n  update_post_meta($post_id, '_regular_price', $price);\n  update_post_meta($post_id, '_price', $price);\n  wp_set_object_terms($post_id, [$cat_id], 'product_cat');\n}\n"
    }
  ]
}

The skill ensures the agent includes require '/wordpress/wp-load.php' at the top of every runPHP step. Without this line, all WordPress functions fail silently — a mistake agents make frequently without the skill reference.

WordPress Playground Loading a store with 5 products in a woo store.

4. Inline mu-plugin for custom behavior

Prompt:

Write a Blueprint that disables the admin bar and adds a custom
dashboard widget showing the server's PHP version.

Generated Blueprint:

{
  "$schema": "https://playground.wordpress.net/blueprint-schema.json",
  "landingPage": "/wp-admin/",
  "preferredVersions": { "php": "8.3", "wp": "latest" },
  "steps": [
    { "step": "login" },
    {
      "step": "writeFile",
      "path": "/wordpress/wp-content/mu-plugins/custom-dashboard.php",
      "data": "<?php\nadd_filter('show_admin_bar', '__return_false');\n\nadd_action('wp_dashboard_setup', function() {\n  wp_add_dashboard_widget(\n    'php_version_widget',\n    'PHP Version',\n    function() {\n      echo '<p>Running PHP ' . phpversion() . '</p>';\n    }\n  );\n});"
    }
  ]
}

The agent uses writeFile to create a mu-plugin, which loads automatically without activation. The skill explicitly documents this pattern and warns agents not to add require wp-load.php inside mu-plugin code (that line is only needed in runPHP steps).

5. Blueprint bundle with a custom plugin

Prompt:

Create a Blueprint bundle that installs a custom analytics plugin
from a local zip file.

Generated bundle structure:

analytics-bundle/
├── blueprint.json
└── analytics-plugin.zip

blueprint.json:

{
  "$schema": "https://playground.wordpress.net/blueprint-schema.json",
  "landingPage": "/wp-admin/plugins.php",
  "preferredVersions": { "php": "8.3", "wp": "latest" },
  "steps": [
    { "step": "login" },
    {
      "step": "installPlugin",
      "pluginData": {
        "resource": "bundled",
        "path": "/analytics-plugin.zip"
      },
      "options": { "activate": true }
    }
  ]
}

Run it locally:

npx @wp-playground/cli server --blueprint=./analytics-bundle/ --blueprint-may-read-adjacent-files

The --blueprint-may-read-adjacent-files flag is required for directory bundles. Without it, any bundled resource reference fails with a “File not found” error. The skill documents this gotcha, so agents include the flag automatically.

How the blueprint skill fits with other tools

The blueprint skill works alongside two other Playground tools for AI agents:

Tool	What it does	When to use it
Blueprint skill	Generates valid Blueprint JSON	When you need a Blueprint file for sharing, version control, or CI
wp-playground skill	Runs CLI commands, manages servers, debugs instances	When you need a running Playground instance with live interaction
MCP server	Connects agents directly to a browser Playground	When you need real-time 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 execution and file manipulation

Use the blueprint skill when you want a portable, reproducible configuration. Use the wp-playground skill when you need a running server. Combine them: generate a Blueprint with the blueprint skill, then launch it with the wp-playground skill’s CLI commands.

Test your Blueprints

Inline URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org (quick test)

Minify the Blueprint JSON and append it to the Playground URL:

https://playground.wordpress.net/#{"preferredVersions":{"php":"8.3","wp":"latest"},"steps":[{"step":"login"}]}

Local CLI (full test)

# Start a server with your Blueprint
npx @wp-playground/cli server --blueprint=./blueprint.json

# Headless validation (runs and exits)
npx @wp-playground/cli run-blueprint --blueprint=./blueprint.json

Get started

Install the blueprint skill in your project:

npx skills add wordpress/agent-skills --skill blueprint

Then ask your agent to write a Blueprint. Describe what you need: plugins, themes, content, configuration, and the agent produces valid JSON that runs on the first try.

Share what you build in the #playground channel on Making WordPress Slack or open an issue on GitHub.

#agent-skills, #ai

Fellyph Cintra 11:53 am on March 30, 2026

Playground Meetings Summaries – March 2026

This post summarizes the WordPress Playground team’s biweekly meetings held on March 13 and March 27, 2026. These meetings are open to all contributors and community members.

March 13, 2026

The meeting was facilitated by @fellyph.

Announcements

my.wordpress.net — The team published an official release post for my.wordpress.net and has been collecting community feedback.

Two new blog posts are available on the Playground Blog:

Simplify your workflow with the new Playground CLI start command — Introduces the new start command, designed to simplify local WordPress environment setup.
How WordPress Playground cut PHP.wasm binary sizes by 122 MB — Covers two compiler flag changes that reduced PHP.wasm binary sizes from 888 MB to 766 MB.

WordPress 7.0 betaBeta A pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 5 is available for testing on Playground. Contributors are encouraged to test their plugins and themes ahead of the next WordPress release at playground.wordpress.net/?wp=beta.

MCP Server — WordPress Playground now has an MCP server. Usage instructions are available on the npm page. A dedicated blog post is in progress.

WASM I/O Conference — Part of the Playground team will be presenting at the WASM I/O conference in Barcelona, March 19–20.

Updates from contributors

Website — Received reliability improvements, including updates to file handling and session persistence, plus integration of the new MCP server.

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-WASM — Updated with performance improvements, the new binary optimization strategy, and memory usage fixes.

Docs — Two new guides are now available:

Both guides received translations in Portuguese, Spanish, and French.

CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. — Updates focus on performance and developer experience. A native php command now enables direct script execution and WP-CLIWP-CLI WP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/ https://make.wordpress.org/cli/-style workflows. The testing suite now uses local PHARs to remove external download dependencies.

@fellyph — Created the two new guides above, drafted the MCP server blog post, drafted a Vitest guide, and worked on a design proposal for the new Wizard page for my.wordpress.net.

March 27, 2026

The meeting was facilitated by @fellyph.

Announcements

MCP Server post published — The post Connect AI coding agents to WordPress Playground with MCP is now live on the Playground Blog. A video walkthrough is also available.

25 pull requests were merged since the last meeting.

my.wordpress.net — Received significant attention from the media and community. The team thanks everyone who shared feedback. The modal design has been updated, removing the purple background. iOSiOS The operating system used on iPhones and iPads. experience improvements are still under investigation, with thanks to @ashfame and @zaerl for looking into the reported issues.

Website PRs

Improvements focus on resilience and edge-case compatibility: better handling of download failures (#3348), fixes for Playground breaking inside in-app browsers like LinkedIn (#3387, #3392), more flexible blueprint ZIP uploads (#3223), My WordPress branding updates (#3390), and added WebKit and Playwright E2E tests (#3379, #3405).

CLI PRs

The CLI now automatically restarts with JSPI support enabled, without manual Node flags (#3281), and uses a faster built-in method for process checking during temp directory cleanup (#3395). Additional improvements include module-boundary linting (#3410), a new Playwright-based benchmarking suite for site editor startup and interaction times (#3408), and silencing harmless streaming errors caused by client disconnects (#3397).

Docs PRs

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 by the repository owner. https://github.com/ Releases are now auto-generated after every npm publish (#3429, #3430). The Claude agent’s permissions have been hardened: rm commands are now blocked (#3398), and allow/deny lists have been updated to prevent destructive actions while permitting read-only git operations (#3373). Dependabot’s config was also fixed to properly exclude directories (#3426).

SQLite

#3428 — Updated the SQLite database path from .ht.sqlite to .ht.sqlite.php to match the latest SQLite 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..
#3435 — Reverted that path update.

PHP-WASM

#3417 — Fixed Redis extension corruption in WASM32 caused by a variadic ABI mismatch.
#3399 — Fixed a race condition in proc_open where pipe writes could crash after streams were already closed.

Updates from contributors

@fellyph — Published the E2E Testing with Playwright guide, published the MCP server post, drafted the Vitest guide, and started writing about recent architecture changes.

@brandonpayton and @ashfame — Exploring performance improvements for the Playground CLI, including HTTPHTTP HTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands./2 and static file serving optimizations. @brandonpayton is also focusing on PR reviews.

@adamzielinski — Working on a WordPress site migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. plugin. A working Blueprint with a demo is available. This will be a useful integration for working on existing sites directly within Playground.

@bero — Focused on enabling AI agents to use Playground. A Blueprint skill is now available, and agents will soon be able to interact with the Playground website via playgroundSites methods from DevTools. Experimental WebMCP support is also being added. Next steps include more MCP tools and skills to improve the agent experience.

@janjakes — Back to SQLite work, focusing on monorepo setup, automation, and the upcoming v3 release.

Open floor

@fellyph asked whether contributors prefer a monthly report or a per-meeting report for the Playground newsletter, noting concern about email frequency for subscribers.

The next meeting will be held on April 10, 2026. All are welcome.

Fellyph Cintra 11:02 am on March 17, 2026
Tags: ai ( 2 ), playground ( 4 )

Connect AI coding agents to WordPress Playground with MCP

What if your coding agent could read WordPress files, execute 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, and manage sites directly in your browser? The @wp-playground/mcp package bridges AI coding agents and a browser-based Playground instance through the Model Context Protocol (MCP). Run one command to connect. No configuration needed in Playground.

How it works

The MCP server runs as a local Node.js process using stdio transport. Your AI client communicates with it directly, and the server forwards commands to a Playground instance running in your browser through a WebSocket connection.

AI Client (stdio) --> MCP Server (Node.js) --> WebSocket --> Browser (Playground)

When you open Playground in your browser, a WebSocket links the browser tab to the MCP server. The server assigns a random local port at startup and passes it to the browser through the URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org’s mcp-port parameter. The server translates your agent’s tool calls into direct Playground actions: reading files, executing PHP, and navigating pages.

The connection stays local to your machine. Origin restrictions and token-based authentication at startup prevent unauthorized access from other sites and browser extensions.

Set up the MCP server

Claude Code

claude mcp add --transport stdio --scope user wordpress-playground -- npx -y @wp-playground/mcp

The --scope user flag makes the server available across all your projects. Use --scope local to restrict it to the current project only.

Gemini CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress.

gemini mcp add wordpress-playground npx -y @wp-playground/mcp

The default transport is stdio. Use -s user for a user-wide scope.

JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. configuration

You can also configure the server manually. Add this to your .mcp.json (Claude Code / Claude Desktop):

{
    "mcpServers": {
        "wordpress-playground": {
            "type": "stdio",
            "command": "npx",
            "args": ["-y", "@wp-playground/mcp"]
        }
    }
}

Gemini CLI uses the same structure in settings.json but without the "type" field.

After setup, open Playground in your browser. The agent provides the exact URL when it connects.

Three practical workflows

Once connected, your agent manages WordPress through natural language.

1. Install, test and build a 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.

Ask your agent to install and verify a plugin without touching the WordPress admin:

“Install the Classic Editor plugin on my Playground site and confirm it deactivates the 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. editor.”

The agent uses playground_execute_php to call wp_remote_get, download the plugin zip, and extract it to wp-content/plugins/. It activates the plugin with activate_plugin(), then fires playground_request against the post editor URL to confirm the classic interface loads. You see each step in your agent’s output.

2. Debug site options with PHP

Need to check what a plugin stored in the database? Skip the admin UIUI UI is an acronym for User Interface - the layout of the page the user interacts with. Think ‘how are they doing that’ and less about what they are doing. and query wp_options directly:

“Show me all autoloaded options that contain ‘woocommerce’ in the option name.”

The agent runs playground_execute_php with a short script:

global $wpdb;
$results = $wpdb->get_results(
    "SELECT option_name, option_value FROM $wpdb->options
     WHERE option_name LIKE '%woocommerce%'"
);
print_r($results);

Playground uses SQLite instead of 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, so avoid MySQL-specific column values in your queries. The $wpdb abstraction handles the translation, but filterFilter Filters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. conditions like autoload = 'yes' may not return results as expected.

The output appears in your conversation. No phpMyAdmin or database client needed.

3. Scaffold theme files

Building a child themeChild theme A Child Theme is a customized theme based upon a Parent Theme. It’s considered best practice to create a child theme if you want to modify the CSS of your theme. https://developer.wordpress.org/themes/advanced-topics/child-themes/ from scratch involves creating directories, writing template files, and registering the theme. Let the agent handle the boilerplate:

“Create a child theme of Twenty Twenty-Five called ‘Studio Child’ with a custom headerHeader The header of your site is typically the first thing people will experience. The masthead or header art located across the top of your page is part of the look and feel of your website. It can influence a visitor’s opinion about your content and you/ your organization’s brand. It may also look different on different screen sizes. template part and a front-page template.”

The agent calls playground_mkdir to create the theme directory, playground_write_file to generate style.css, theme.json, and template files, then playground_execute_php to verify the theme appears in the admin. If a file contains an error, the agent reads it back with playground_read_file and corrects the mistake in the next step.

Available tools

The MCP server exposes these tools to your agent:

Site management: playground_get_website_url, playground_list_sites, playground_open_site, playground_rename_site, playground_save_site
Code execution: playground_execute_php, playground_request
Navigation: playground_navigate, playground_get_current_url, playground_get_site_info
Filesystem: playground_read_file, playground_write_file, playground_list_files, playground_mkdir, playground_delete_file, playground_delete_directory, playground_file_exists

Share your feedback

Try the @wp-playground/mcp package and tell us what you build. Share your experience in the #playground channel on Making WordPress Slack or open an issue on GitHub to suggest new tools.

Props to @berislavgrgicak for building the MCP server and reviewing the post.

#ai #playground

+make.wordpress.org/core/
+make.wordpress.org/ai/

Fellyph Cintra 6:35 pm on March 11, 2026

How WordPress Playground cut PHP.wasm binary sizes by 122 MB

Every 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 version WordPress Playground supports ships as a WebAssembly binary. Across all builds and versions, those binaries totaled 888 MB. Two compiler flag changes reduced that to 766 MB, a 122 MB saving (13.7%) without removing a single feature.

What changed?

Playground compiles PHP to WebAssembly using Emscripten. The compiler flag MAIN_MODULE controls which symbols get exported for dynamic linking. Previously, Playground used MAIN_MODULE=1, which exports everything, including thousands of symbols that no extension ever calls.

Switching to MAIN_MODULE=2 tells Emscripten to export only the symbols extensions actually use, similar to tree-shaking in 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 bundlers. The compiler drops everything else.

The challenge: keeping extensions alive

Flipping a compiler flag sounds simple, but MAIN_MODULE=2 aggressively eliminates code that the main module considers “dead.” Playground loads extensions like Intl, Xdebug, Memcached, and Redis as dynamic .so modules, and those modules depend on specific symbols from the main PHP binary. Remove the wrong symbol, and the extension crashes on load.

PR #3244 first mapped the approach: scanning each compiled extension wasm-dis to extract which symbols it references. The build system then feeds those symbols back to the linker as explicit exports, keeping every extension working while eliminating thousands of unused ones.

Three extensions required direct fixes. Xdebug required a __c_longjmp WebAssembly tag injection. Memcached called recv and setsockopt through libmemcached internals, so the build added C shim wrappers. Intl alone needed over 5,000 export symbols, including libc++ functions.

Why two build types?

PHP is synchronous. Browsers are not. Playground solves this mismatch with two compilation strategies, and each one produces a separate set of binaries:

Asyncify transforms compiled code at build time so it can pause and resume execution. This approach works in every browser but adds overhead to the binary. Learn more about Asyncify.
JSPI (JavaScript Promise Integration) takes a different approach. It lets WebAssembly call async browser APIs directly, without transforming the compiled code. JSPI produces smaller binaries but currently requires V8-based browsers (Chrome, Edge). Learn more about JSPI.

Playground ships both variants for each PHP version, so the MAIN_MODULE=2 optimization is applied to both:

PR #3332 targeted JSPI builds.
PR #3335 completed the same change for Asyncify builds.

The numbers

Metric	Before	After	Saved
Total binary size	888 MB	766 MB	122 MB (13.7%)
`.wasm` files	680 MB	571 MB	109 MB (16%)
JS glue code	22.7 MB	8.2 MB	14.5 MB (63%)

Per-version .wasm sizes dropped consistently across all supported PHP versions:

PHP Version	Before (avg)	After (avg)	Reduction
7.4	~20 MB	~17 MB	17-19%
8.2	~25 MB	~21 MB	15-17%
8.4	~27 MB	~23 MB	14-16%
8.5	~28 MB	~24 MB	14-15%

The two PRs combined removed 554,793 lines of JavaScript glue code across all builds.

Why smaller binaries matter

Faster downloads and CI. 122 MB fewer bytes to transfer during repository clones, CI pipelines, and deployments. That adds up across all contributors and all automated runs.

Faster WebAssembly instantiation. Smaller .wasm files compile faster in the browser. Compilation cost scales roughly with binary size, so 16% smaller binaries translate directly to faster WordPress startup.

Lower memory usage. Fewer exported symbols produce a smaller function table. The runtime allocates less memory before PHP even starts.

Faster JavaScript parsing. 63% less JS glue code means the browser parses and evaluates significantly less JavaScript before handing control to PHP.

What this means for `php-wasm` packages

Version-specific packages like @php-wasm/web-8.4 and @php-wasm/node-8.4 ship lighter binaries. No APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. changes — this is purely a build optimization. Existing code that depends on these packages works unchanged.

What comes next

The next step is to benchmark the runtime impact by measuring instantiation time, time-to-first-PHP-response, and memory usage across builds. Those numbers will confirm how the smaller binaries translate to real-world performance gains.

Props to @mho22 for implementing both PRs and reviewing the post, @brandonpayton for reviewing, and @adamziel for the architectural direction. See the full details in PR #3332 and PR #3335.

Fellyph Cintra 12:22 pm on March 3, 2026

Playground Meetings Summaries – February 2026

This post covers the two Playground meetings held in February 2026. These are bi-weekly chats where contributors to WordPress Playground gather to discuss updates, ongoing work, and plans for current and future releases. All are welcome to join.

Meeting 1 – February 13, 2026

Facilitator: Fellyph Cintra

Announcements

Three posts worth highlighting from the past weeks:

wp-env now runs WordPress with Playground runtime — WordPress Playground is now available in wp-env as an alternative to Docker.
What’s new for developers? (February 2026) — A roundup of developer-focused updates from the beginning of the year, including several Playground highlights.
WordPress Studio 1.7.0 received substantial CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. updates — nearly every feature is now controllable from the command line, improving compatibility with AI-assisted development tools such as Claude Code and Cursor.

Documentation

Three documentation pull requests landed since the last meeting:

#3188 — Refreshes screenshots and rewrites content for the web instance page to reflect the latest UIUI UI is an acronym for User Interface - the layout of the page the user interacts with. Think ‘how are they doing that’ and less about what they are doing..
#3242 — Updates the “Host Your Own Playground” self-hosting page with current instructions and improved clarity.
#3103 — Adds a new beginner-friendly “Playground for Everyone” guide explaining what WordPress Playground is and how anyone can use it.

Translations

New translations were added for Bengali and Japanese. Thank you to @noruzzaman and @shimomura tomoki for their contributions.

#3177 — Updates translations.md for multiple languages.
#3249, #3230, #3229, #3231 — Bengali translations for several guides and documentation pages.
#3228 — Japanese translations for developer architecture, 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, and browser-concepts pages.

Other notable changes

Website — A new URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org route enables deep-linking directly to the Blueprint Gallery overlay using the ?overlay=blueprints parameter.
CLI — A new --phpmyadmin flag spins up a phpMyAdmin instance for inspecting and managing the SQLite database from the command line.
Blueprints — Removed an unnecessary dependency on @php-wasm/web from the blueprints package, reducing bundle size and decoupling the two packages.
Safari — Multiple improvements shipped following community feedback shared on X.

In total, 32 pull requests were merged since the last meeting.

Updates from contributors

Fellyph Cintra — Researching the migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. of Playground documentation to the .org Handbook, documenting the process of integrating Playground with code agents, and submitting a new skill for 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. pattern creation to the WordPress repository.
Brandon Payton — Continuing work on making multi-worker mode non-experimental in the Playground CLI, with expanded test coverage now running on Windows, macOS, and Linux.
Jan Jakes (@janjakes) — Added phpMyAdmin support to the Playground CLI. Try it with npx @wp-playground/cli@latest server --phpmyadmin. An overview post on the SQLite side is also coming soon.
Adam Zieliński — Working on importing WordPress sites between hosts, which will enable moving sites between Playground instances and hosted environments.

Open floor

Fellyph shared a demo of WordPress Playground used together with Claude Code and the DevTools MCP server, highlighting how Claude Code decides whether to fix code directly or use the Site Editor to fulfill requests. The team is curious to hear from the community: are you using Playground with code agents, and what has your experience been like?

If you are interested in contributing to the documentation migration to the .org Handbook, reach out to Fellyph directly via SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ DM.

Meeting 2 – February 27, 2026

Facilitator: Fellyph Cintra

Announcements

The team is currently investigating stability issues affecting WordPress Playground with WordPress 7.0 BetaBeta A pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. and GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ v22.6.0. Two related pull requests are in progress:

#3312 — Avoids cross-origin policy errors in the editor.
#3301 — Fixes a blank /wp-admin page caused by responses crossing the Comlink worker boundary.

Thanks to everyone who reported issues — your feedback helped with the investigation. More fixes are expected in the coming days.

Two posts were published this week:

WordPress 7.0 Beta 2 is now available for testing on WordPress Playground. If you encounter any issues, please report them on 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 by the repository owner. https://github.com/.

Project updates

22 pull requests have been merged since the last meeting. New feature work was paused to focus on WordPress 7.0 stability investigations.

CLI

#3288 — Removes a duplicated “Playground CLI Ready” log line to keep startup output clean.
#3238 — Detects “port already in use” errors and returns a clear, actionable message.
#3150 — Fixes Windows native file-locking issues in the multi-threaded CLI architecture.

PHP.wasm

#3287 — Adds PHP function names and refactors the test suite to improve coverage and maintainability.
#3234 — Adds a cp (copy) method to Universal PHP for file duplication via the PHP.wasm filesystem APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways..

Translations

New translations were added for Bengali and Japanese. Thank you to @noruzzaman and @shimomura tomoki for their continued contributions.

Documentation

A new guide is available: Using the WordPress Playground Agent Skill.
Following feedback from the previous meeting, CLAUDE.md has been migrated to AGENTS.md.

Updates from contributors

Fellyph Cintra — Migrating the documentation to the .org Handbook, working on the Agent Skill guide and the two CLI posts. Started testing Playground with Claude Code and Gemini HooksHooks In WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same.; a post about it is coming soon.
Jan Jakes (@janjakes) — Improving the agentic experience and setup for Playground and SQLite integration, and investigating performance and memory consumption.
Yannick Decat — Compiling PHP.wasm with MAIN_MODULE=2 to reduce .wasm and .js file sizes, and implementing path mappings and path skipping in Xdebug 3.5. Also experimenting with Xdebug in the browser.
Bero — Working on an MCP server for the Playground website, including WebMCP support.
Adam Zieliński — The WordPress site migrator is working. Next steps include URL rewriting for cross-domain moves and Playground integration.

Open floor

The team discussed what tools would be most useful in an MCP server for Playground. If you have ideas, share them in the comments below or on the relevant GitHub pull requests.

The next Playground chat will be on March 10th in the #playground Slack channel. All are welcome to join.

Fellyph Cintra 6:41 pm on February 24, 2026

Simplify your workflow with the new Playground CLI start command

Setting up a local WordPress environment should be as simple as running a single command. We are excited to introduce the new start command in the WordPress Playground CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress., simplifying how you run your local environments.

A simpler way to start

The WordPress Playground CLI is a powerful tool for running WordPress in your terminal. The command server allows users to customize the Playground instance at several levels, but those customizations can be daunting for users who want to run a WordPress instance with a theme/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.. With the introduction of the high-level start command (introduced in PR #3040), you can launch a local WordPress instance more intuitively.

Instead of configuring complex parameters, you can now run:

npx @wp-playground/cli start

This command automatically configures the environment with sensible defaults, so you can focus on building.

Persistence by default

The most significant update in this release is persistence (PR #3119). Previously, closing the CLI meant losing your database and file changes unless you manually configured mounts. This update is a major milestone toward simplifying the WordPress development ecosystem. By adding persistence and a high-level entry point, the Playground CLI achieves feature parity with wp-now.

Now, the start command automatically saves your site’s state in your home directory (~/.wordpress-playground/sites/). This ensures your plugins, themes, and content are preserved between sessions. You can stop your server and resume exactly where you left off.

Quick reset for a fresh start

Sometimes, you need to start over. If you want to wipe your persisted site and begin with a clean installation, use the --reset flag:

npx @wp-playground/cli start --reset

Other flags are available for the `start` command:

--blueprint — Execute a Blueprint file to preconfigure your site with plugins, themes, settings, and content.
--php — Choose your 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 version. Supported versions: 7.4, to 8.5. Defaults to 8.3.
--wp — Set the WordPress version. Defaults to latest.
--port — Define the port for the local server. Defaults to 9400.
--login — Automatically log in to the WordPress dashboard on launch.

Get started

The start command is available now in the latest version of @wp-playground/cli. Whether you’re testing a new plugin or building a theme, the Playground CLI provides a lightweight, zero-config environment directly in your terminal.

To learn more, check the Playground CLI documentation.

Fellyph Cintra 11:21 am on February 20, 2026

Manage your database directly from the Playground CLI

Need to inspect WordPress data, debug a query, or check if a 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. saved options correctly? The Playground CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. now includes a --phpmyadmin flag that launches phpMyAdmin alongside your local WordPress instance. No extra setup, no separate database server, just one command.

Where is your data?

When developing locally with Playground CLI, you often need to verify what the database actually contains. Until now, doing that required writing custom 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 queries or adding debug output to your code.

The --phpmyadmin flag solves this by giving you a full phpMyAdmin interface right from the CLI.

Getting started

Add --phpmyadmin to your regular CLI command:

npx @wp-playground/cli@latest server --phpmyadmin

After WordPress boots, the CLI prints the phpMyAdmin URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org:

WordPress Playground CLI

PHP 8.3  WordPress latest
Extensions intl

Ready! WordPress is running on http://127.0.0.1:9400 (11 workers)

phpMyAdmin available at http://127.0.0.1:9400/phpmyadmin/index.php?route=/database/structure&db=wordpress

Open that URL in your browser, and you get full access to browse tables, run SQL queries, and inspect your WordPress data:

Custom URL path

By default, phpMyAdmin serves at /phpmyadmin. Change this path to anything you prefer:

npx @wp-playground/cli@latest server --phpmyadmin=/my-db

This serves phpMyAdmin at http://127.0.0.1:9400/my-db/index.php instead.

Combine with other CLI flags

The --phpmyadmin flag works alongside all existing CLI options:

Test a plugin and inspect its database changes

npx @wp-playground/cli@latest server --phpmyadmin --auto-mount

Run this from your plugin directory. Playground mounts your plugin automatically, and phpMyAdmin lets you verify the database tables and options your plugin creates.

Pin a specific WordPress and PHP version

npx @wp-playground/cli@latest server --phpmyadmin --wp=latest --php=8.5

Useful when you need to check how your plugin handles data across different WordPress versions.

Use a Blueprint with phpMyAdmin

npx @wp-playground/cli@latest server --phpmyadmin --blueprint=my-blueprint.json

Combine Blueprints with phpMyAdmin to pre-configure your WordPress instance and then inspect the resulting database state.

Cache phpMyAdmin for faster starts

Each time you use --phpmyadmin, Playground downloads and installs phpMyAdmin into the instance. To skip the download on subsequent runs, mount a local directory to cache the files:

mkdir -p ./pma-cache
npx @wp-playground/cli@latest server --phpmyadmin --mount ./pma-cache:/tools/phpmyadmin

The first run populates ./pma-cache with the phpMyAdmin files. On every subsequent run, Playground detects the existing installation and skips the download.

Where this helps

Here are some practical scenarios where --phpmyadmin saves time:

Plugin development: Verify that your plugin creates the correct custom tables and stores data in the expected format.
Debugging options: Check wp_options directly to confirm your plugin settings saved correctly, without writing get_option() debug code.
Content migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. testing: Import content via a Blueprint and verify the resulting posts, terms, and metadata in the database.
Learning WordPress internals: Explore how WordPress organizes its database tables — see how posts relate to postmeta, how taxonomies link to terms, and how user data connects across tables.
SQL query testing: Run raw SQL queries against your test data before embedding them in your plugin code.

How it works under the hood

phpMyAdmin installs at /tools/phpmyadmin on the virtual filesystem — outside the WordPress document root at /wordpress. The CLI uses a path alias (similar to NginxNGINX NGINX is open source software for web serving, reverse proxying, caching, load balancing, media streaming, and more. It started out as a web server designed for maximum performance and stability. In addition to its HTTP server capabilities, NGINX can also function as a proxy server for email (IMAP, POP3, and SMTP) and a reverse proxy and load balancer for HTTP, TCP, and UDP servers. https://www.nginx.com/.’s alias directive) to serve it at your chosen URL path. This design keeps phpMyAdmin files separate from your WordPress installation, so they never appear in site exports or interfere with your project files.

Since Playground uses SQLite instead of 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, phpMyAdmin connects through a custom MySQL-on-SQLite driver that translates queries between the two dialects.

Share your feedback

The phpMyAdmin integration in the CLI came from the same effort that brought the Database panel to the Playground web interface. If you run into issues or have suggestions, share them on the Making WordPress Slack or open an issue on GitHub.

Props to @JanJakes for reviewing this post.

Fellyph Cintra 12:10 pm on February 6, 2026

wp-env now runs WordPress with Playground runtime

wp-env is one of the alternatives to run a WordPress Environment; by default, it uses Docker. What if you could run a full WordPress development environment without installing Docker? With the new experimental Playground runtime for wp-env, you can.

One command. Zero Docker. Full WordPress:

npx @wordpress/env start --runtime=playground

This launches a complete WordPress environment in seconds using Node.js.

Why does this matter?

The Playground runtime offers a lightweight alternative for WordPress development. No extra software installation required; if you have Node.js, you’re ready to go.

What makes the Playground runtime appealing:

Zero additional installation – Just Node.js, no Docker setup needed
Lightweight bundle – WordPress Playground runs lean with minimal resource usage
Fast startup – Get a running WordPress instance in seconds
Works everywhere Node.js runs – Linux, macOS, Windows, CI pipelines

What works in both runtimes?

The good news: most wp-env features work identically in both runtimes. Here’s the official comparison:

Feature	Docker	Playground
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./theme mounting	✅	✅
Custom 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 versions	✅	✅
Xdebug support	✅	✅
MultisiteMultisite Multisite is a WordPress feature which allows users to create a network of sites on a single WordPress installation. Available since WordPress version 3.0, Multisite is a continuation of WPMU or WordPress Multiuser project. WordPress MultiUser project was discontinued and its features were included into WordPress core. Advanced Administration Handbook -> Create A Network.	✅	✅ (experimental)
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 database	✅	❌ (SQLite)
phpMyAdmin	✅	❌ (planned)
SPX profiling	✅	❌
Separate tests environment	✅	❌
wp-env run command	✅	❌

The Playground runtime uses SQLite instead of MySQL. For most WordPress development, you won’t notice the difference; your plugins and themes work the same way.

Multisite support is available but hasn’t been extensively tested yet, so treat it as experimental for now.

phpMyAdmin is not yet supported in the Playground runtime. Once it becomes available in the Playground CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress., wp-env will integrate it. You can already use phpMyAdmin directly with the Playground CLI:

npx @wp-playground/cli server --phpmyadmin              # serves at http://127.0.0.1:9400/phpmyadmin
npx @wp-playground/cli server --phpmyadmin=/custom-path # serves at http://127.0.0.1:9400/custom-path

What about my existing configuration?

The Playground runtime supports most existing .wp-env.json configuration files:

{
  "core": "WordPress/WordPress#6.8",
  "plugins": ["./my-plugin"],
  "themes": ["./my-theme"],
  "phpVersion": "8.2"
}

This configuration works with both runtimes. Once you start wp-env with a specific runtime, wp-env remembers your choice. Subsequent commands wp-env stop automatically use the same runtime. To switch runtimes, destroy the environment with wp-env destroy and start fresh with your preferred runtime flag.

When should you still use Docker?

The Playground runtime is experimental. Choose Docker when you need:

A separate test environment – Docker’s wp-env creates an isolated instance for running tests
The wp-env run command – Execute arbitrary commands inside the environment
MySQL database – Some plugins require MySQL-specific features that SQLite doesn’t support
SPX profiling – Performance profiling with the SPX extension
SSHSSH Secure SHell - a protocol for securely connecting to a remote system in addition to or in place of a password. access – Shell into the environment directly

For development workflows that require deep environment access, running WP-CLIWP-CLI WP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/ https://make.wordpress.org/cli/ commands inside the environment, debugging PHP processes, or customizing the server stack, Docker remains the right choice.

Resources:

Share your feedback

This feature is experimental, and your feedback shapes its direction. Does it work for your workflow? What’s missing? What breaks?

Share your experience at #playground SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ channel.

Props to Riad Benguella(@youknowriad) for announcing and advocating this feature, and to Jan Jakeš(@janjakes) for his work on phpMyAdmin and the Playground CLI.

Jonathan Desrosiers 8:18 am on February 1, 2026
Tags: make.wordpress.org/ai, p2-xpost ( 3 )

X-post: AI Guidelines for WordPress

X-comment from +make.wordpress.org/ai: Comment on AI Guidelines for WordPress

The Challenge: Docusaurus vs. Handbook Formatting

Progress Report: What We’ve Completed & What’s in Progress

The Migration Roadmap

Phase 1: The English Migration

Phase 2: Internationalization (i18n)

Phase 3: The “Ask AI” Feature

Next Steps

What the blueprint skill does

How to install the skill

Five examples

1. Quick development environment

3. WooCommerce store with sample products

4. Inline mu-plugin for custom behavior

5. Blueprint bundle with a custom plugin

How the blueprint skill fits with other tools

Test your Blueprints

Inline URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org (quick test)

Local CLI (full test)

Get started

March 13, 2026

Announcements

Updates from contributors

March 27, 2026

Announcements

Website PRs

CLI PRs

Docs PRs

SQLite

PHP-WASM

Updates from contributors

Open floor

How it works

Set up the MCP server

Claude Code

Gemini CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress.

JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. configuration

Three practical workflows

2. Debug site options with PHP

3. Scaffold theme files

Available tools

Share your feedback

What changed?

The challenge: keeping extensions alive

Why two build types?

The numbers

Why smaller binaries matter

What this means for php-wasm packages

What comes next

Meeting 1 – February 13, 2026

Announcements

Documentation

Translations

Other notable changes

Updates from contributors

Open floor

Meeting 2 – February 27, 2026

Announcements

Project updates

Updates from contributors

Open floor

A simpler way to start

Persistence by default

Quick reset for a fresh start

Get started

Where is your data?

Getting started

Custom URL path

Combine with other CLI flags

Test a plugin and inspect its database changes

Pin a specific WordPress and PHP version

Use a Blueprint with phpMyAdmin

Cache phpMyAdmin for faster starts

Where this helps

How it works under the hood

Share your feedback

Site resources

What this means for `php-wasm` packages