WordPress Playground

WordPress Playground
Skip to content
WordPress Playground
X-post from
+make.wordpress.org/core
WordPress Core Dev Environment Toolkit: A Faster Path to Your First Core Contribution
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.org
WordPress.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.
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
core
Core
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
migration
Migration
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
Gutenberg
Gutenberg
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.
project, we have created a
JSON
JSON
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
GitHub
GitHub
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.
, 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
header
Header
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 “
block
Block
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
WordCamp
WordCamp
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.
Asia
fellyph
will be present and will lead the Contributor table for WordPress. One of the themes of the
contributor day
Contributor 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
There are many teams that people can participate in, each with a different focus.
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.
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
JSON
JSON
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 (
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
CLI
CLI
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,
GitHub
GitHub
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.
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.
2.
Plugin
Plugin
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
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": " $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.
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": "Running PHP ' . phpversion() . '

';\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
PHP
PHP
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.
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
URL
URL
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:
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
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
beta
Beta
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.
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.
PHP
PHP
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.
-WASM
— Updated with performance improvements, the new binary optimization strategy, and memory usage fixes.
Docs
— Two new guides are now available:
E2E Testing with Playwright and WordPress Playground
Programmatic Usage of Playground CLI
Both guides received translations in Portuguese, Spanish, and French.
CLI
CLI
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-CLI
WP-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
-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.
iOS
iOS
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
GitHub
GitHub
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.
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
plugin
Plugin
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
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
HTTP
HTTP
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
migration
Migration
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
What if your coding agent could read WordPress files, execute
PHP
PHP
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.
, 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
URL
URL
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
CLI
CLI
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.
JSON
JSON
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
plugin
Plugin
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
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
block
Block
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
UI
UI
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
MySQL
MySQL
MySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored.
, so avoid MySQL-specific column values in your queries. The
$wpdb
abstraction handles the translation, but
filter
Filter
Filters are one of the two types of 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 theme
Child 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.
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
header
Header
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
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/
Every
PHP
PHP
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.
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
JavaScript
JavaScript
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.
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
API
API
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
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
CLI
CLI
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
UI
UI
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,
PHP
PHP
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.
, and browser-concepts pages.
Other notable changes
Website
— A new
URL
URL
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
migration
Migration
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
block
Block
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
Slack
Slack
Slack is a Collaborative Group Chat Platform
. The WordPress community has its own Slack Channel at
DM.
Meeting 2 – February 27, 2026
Facilitator: Fellyph Cintra
Announcements
The team is currently investigating stability issues affecting WordPress Playground with WordPress 7.0
Beta
Beta
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
Gutenberg
Gutenberg
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.
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:
Simplify your workflow with the new Playground CLI start command
Manage your database directly from the Playground CLI
WordPress 7.0 Beta 2 is now available for testing on
WordPress Playground
. If you encounter any issues, please report them on
GitHub
GitHub
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.
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
API
API
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
Hooks
Hooks
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.
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
CLI
CLI
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/
plugin
Plugin
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
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
PHP
PHP
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.
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
Need to inspect WordPress data, debug a query, or check if a
plugin
Plugin
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
or can be cost-based plugin from a third-party.
saved options correctly? The Playground
CLI
CLI
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
PHP
PHP
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.
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
URL
URL
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
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
migration
Migration
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
Nginx
NGINX
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.
’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
MySQL
MySQL
MySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored.
, 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.
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
Plugin
Plugin
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
or can be cost-based plugin from a third-party.
/theme mounting
Custom
PHP
PHP
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.
versions
Xdebug support
Multisite
Multisite
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)
MySQL
MySQL
MySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored.
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
CLI
CLI
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
SSH
SSH
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-CLI
WP-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
commands inside the environment, debugging PHP processes, or customizing the server stack, Docker remains the right choice.
Resources:
wp-env documentation
WordPress Playground
Report issues on GitHub
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
Slack
Slack
Slack is a Collaborative Group Chat Platform
. The WordPress community has its own Slack Channel at
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.
Site resources
Links
WordPress Playground page
Playground documentation
Contributing to WordPress Playground
Email Updates
Enter your email address to subscribe to this blog and receive notifications of new posts by email.
Join 16 other subscribers
Meetings
Join us in the
#playground
channel
Playground Team Meeting
Fri May 8 14:00:00 2026 UTC
(2 weeks from now) accessible via
#playground
on Slack
Recent Posts
X-post: WordPress Core Dev Environment Toolkit: A Faster Path to Your First Core Contribution
Migrating WordPress Playground Documentation to WordPress.org
Teach your coding agent to write WordPress Playground Blueprints
Playground Meetings Summaries – March 2026
Connect AI coding agents to WordPress Playground with MCP
Recent Comments
Archives
April 2026
March 2026
February 2026
January 2026
December 2025
November 2025
October 2025
August 2025
July 2025
June 2025
December 2024
November 2024
October 2024
September 2024
August 2024
Categories
Meetings
status
Updates
Recent Updates
Recent Comments
No Replies
Recent Activity
Team Pledges
155 people
have pledged time to contribute to Playground Team efforts! When looking for help on a project or program, try starting by reaching out to them!
compose new post
reply
edit
go to top
go to the next post or comment
go to the previous post or comment
toggle comment visibility
esc
cancel edit post or comment