BERJAYA Fellyph Cintra 1:29 pm on May 11, 2026  

Playground Meetings Summaries – April 2026

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

Meeting โ€“ April 10, 2026

Facilitator: @fellyph

Announcements

  • 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 2026 was still running during the meeting. Talks were available via livestream. Thanks to @dilipmodhavadiya, @gauravbhai, @rimaprajapati, @shailmehta, and @arslan for joining 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/ table.
  • @Bero published a new Agent Skill to help coding agents write Blueprints. Read the announcement: Teach your coding agent to write WordPress Playground Blueprints.
  • The Playground team has started the process to migrate the documentation to the 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/ Handbook format. Read the announcement: Migrating WordPress Playground Documentation to WordPress.org.
  • Two new contributors received the Playground badge, bringing the total to 55 contributors.
  • Since the last meeting, through April 10, 2026, 19 pull requests have been merged, with several others still under review.

Updates by area

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 and Xdebug
Improvements to the PHP.wasm tooling, including AI-friendly build documentation and enhanced Xdebug support. Critical Node.js host crashes caused by closed streams were fixed. phpMyAdmin and Adminer were upgraded to support PHP 8.5 and now read SQLite settings directly from the WordPress configuration rather than from hardcoded paths.

CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress.
Recent CLI updates improved stability and configuration flexibility. An intermittent boot crash caused by directory mount conflicts was fixed, along with a false database error reported by users running an external 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. Developers can now override WP_DEBUG settings using boolean or numeric values, and beta is now accepted as a valid WordPress version slug.

Playground website
Updates introduced a global site management 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., enabled browser-native AI interaction through WebMCP, and clarified the error messages shown when a PR preview has expired.

Documentation
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. to the Handbook is underway. Current work focuses on making the existing Markdown content compatible with the WordPress Handbook format.

Internationalization
New translations landed for Japanese and Bengali.

SQLite
Database handling improvements prevent unexpected wp-config.php rewrites. The SQLite build scripts were also adapted to support the new monorepo structure.

Contributor updates

@fellyph โ€” Worked on recent posts and documentation, fixed the issue with the beta flag in the WordPress CLI, and submitted a fix for the preview button in the CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. AI 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. after spotting an issue while testing it. Also identified several documentation improvements while preparing the talk for WordCamp Asia.

@zieladam โ€” Finalizing site importing for WordPress, with plans to start integrating it shortly with other tools, including WP-CLI, Playground web, and possibly Playground CLI.

@bpayton โ€” Focused on Playground CLI performance improvements and reviewing pull requests. There is still a backlog of pull requests awaiting review.

@janjakes โ€” Preparing a new major version release of the SQLite integration, along with new features coming soon to Playground web.

@ydecat โ€” Cleaning up a package that is no longer needed, making room for new packages. Also working on improving the generation of package.json files across the project, with Xdebug usage examples next on the list and a possible exploration of bringing Xdebug to PHP.wasm Web.

Closing

A recurring piece of feedback heard at WordCamp Asia was about the recent stability and performance improvements in Playground. Thanks to everyone for keeping that work moving.

Meeting โ€“ April 24, 2026

Facilitator: @fellyph

Announcements

  • From April 10, 2026, through April 24, 2026, 35 pull requests were merged. The Playground badge now counts 57 community members.
  • The documentation migration to the Handbook is ongoing, with several important pull requests merged this week.
  • WordCamp Europe is coming up, and the team is looking for community members to co-lead the Playground table. If you are interested, send a direct message to @fellyph.

Updates by area

Website
The main activity focused on improving the site-management 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., restoring browser compatibility, fixing a tricky Safari cross-origin bug, and re-enabling media processing that had been disabled as a workaround.

PHP-WASM
A highly active period for the PHP runtime layer. PHP 5.2 support was added, and several crash bugs were fixed (MEMFS symlinks, gzip/zlib, and TSRMLS_CC). The node-polyfills package was removed as a cleanup, and the bundler documentation was improved.

Blueprints
Activity was mostly documentation and internationalization. The Blueprint bundles reference page was updated, and Bengali and Gujarati translations of the Blueprint tutorial pages were added.

SQLite
One merged pull request shifted the scheduled refresh of the SQLite integration to a different time slot to avoid conflicts.

CLI
Several quality-of-life improvements landed: a new --workers flag, a fix for --no-auto-mount, a test parallelism pin to prevent flaky CI, restored missing mount specs, and Xdebug usage examples.

Documentation and i18n
Improvements continued on making the docs compatible with the WordPress Handbook, including updates around Asyncfy and the overlay property implemented by @bph. New translations landed in Gujarati, Portuguese, Spanish, and French.

Thanks to @shailmehta, @shimomura, @bรฉryl, @ydecat, and @nilovelez for the translation contributions.

Contributor updates

@fellyph โ€” Worked on the documentation migration to the Handbook, updating several pages in English and Portuguese. Reviewed pull requests for the Blueprints library and created an About page for My WordPress in Portuguese.

@zieladam โ€” No major updates this week, except for a new SQLite extension that treats Markdown files as tables. It could make a nice tool for editing Markdown with WordPress.

@mosescursor โ€” Recently focused on organizing WordCamp Asia and contributing to other teams. Now available to contribute to Playground again.

@janjakes โ€” On the SQLite side, tagged 3.0.0-rc.1 and 3.0.0-rc.2 with the following improvements:

  • Remove legacy SQLite driver (#358)
  • Improve concurrent database access (#361)
  • Support MySQL BINARY operator (#369)
  • Add support for AUTO_INCREMENT value management (#367)
  • Add support for DELETE with LIMIT and ORDER BY (#365)
  • Add Query Monitor 4.0 support (#357)
  • Translate MySQL CONVERT() expressions to SQLite (#356)

@bpayton โ€” Exploring a Wasm-based kernel to run Playground in the browser on top of traditional server software, such as 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/., PHP-FPM, and MariaDB. Early results are promising. The goal is to have a query parameter that switches playground.wordpress.net between the current PHP-WASM runtime and the kernel-based runtime. More to share next time.

The next Playground chat will be announced in the #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. All are welcome.

BERJAYA JuanMa Garrido 1:29 pm on April 16, 2026
Tags: make.wordpress.org/core,   

X-post: WordPress Core Dev Environment Toolkit: A Faster Path to Your First Core Contribution

X-post from +make.wordpress.org/core: WordPress Core Dev Environment Toolkit: A Faster Path to Your First Core Contribution

BERJAYA 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:

  1. Duplication of the current format to a Handbook-friendly format.
  2. 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.

BERJAYA Fellyph Cintra 9:42 am on April 2, 2026
Tags: agent-skills, ,   

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:

ToolWhat it doesWhen to use it
Blueprint skillGenerates valid Blueprint JSONWhen you need a Blueprint file for sharing, version control, or CI
wp-playground skillRuns CLI commands, manages servers, debugs instancesWhen you need a running Playground instance with live interaction
MCP serverConnects agents directly to a browser PlaygroundWhen 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

BERJAYA 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:

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.

BERJAYA Fellyph Cintra 11:02 am on March 17, 2026
Tags: ,   

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/

BERJAYA 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

MetricBeforeAfterSaved
Total binary size888 MB766 MB122 MB (13.7%)
.wasm files680 MB571 MB109 MB (16%)
JS glue code22.7 MB8.2 MB14.5 MB (63%)

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

PHP VersionBefore (avg)After (avg)Reduction
7.4~20 MB~17 MB17-19%
8.2~25 MB~21 MB15-17%
8.4~27 MB~23 MB14-16%
8.5~28 MB~24 MB14-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.

BERJAYA 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

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.

BERJAYA 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.

BERJAYA 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:

BERJAYA

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.