Title: WordPress Playground – Page 2

---

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
4:27 pm _on_ May 19, 2026     
Tags: [playground ( 7 )](https://make.wordpress.org/playground/tag/playground/)

# 󠀁[Run PHP examples anywhere with WordPress Playground](https://make.wordpress.org/playground/2026/05/19/run-php-examples-anywhere-with-wordpress-playground/)󠁿

WordPress Playground is expanding beyond full WordPress sites. A recent set of changes
makes Playground a useful lightweight 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/index.php](https://www.php.net/manual/en/index.php)
runtime for documentation, tutorials, examples, and shareable demos.

The headline feature is the new `<php-snippet>` web component. It lets you embed
runnable PHP examples in any web page with one script tag. Readers can edit the 
code, click **Run**, see the output in place, and experiment without installing 
PHP, configuring a server, or leaving the page.

This opens up a new way to teach WordPress and PHP APIs: examples can now be both
readable and executable.

## What changed

In an HTMLHTML HTML is an acronym for Hyper Text Markup Language. It is a markup
language that is used in the development of web pages and websites. page, such as`
index.html`, the new snippet embed is loaded from Playground:

    ```wp-block-code
    <!-- index.html -->
    <script
        type="module"
        src="https://playground.wordpress.net/php-code-snippet.js"
    ></script>

    <php-snippet name="hello.php">
        <script type="application/x-php">
    <?php
    echo "Hello from PHP " . phpversion();
        </script>
    </php-snippet>
    ```

This example is meant to be served as HTML, not evaluated as PHP on the server. 
If you paste the same markup into a `.php` template, the server-side PHP interpreter
will see the raw `<?php` opening tag before the browser does. In that case, escape
the opening tag as `&lt;?php`, load the snippet from an external file with `src`,
or otherwise make sure the browser receives the PHP code as literal text.

The component renders an editable, syntax-highlighted code 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. with a Run button. When the reader
clicks Run for the first time, Playground lazy-loads the runtime in a hidden iframeiframe
iFrame is an acronym for an inline frame. An iFrame is used inside a webpage to 
load another HTML document and render it. This HTML document may also contain JavaScript
and/or CSS which is loaded at the time when iframe tag is parsed by the user’s browser.,
runs the PHP, and displays the output below the snippet.

Multiple snippets on the same page can share the same runtime. That means a tutorial
can include several examples without downloading and booting a separate PHP environment
for each one.

## WordPress APIs work too

By default, snippets run inside a real WordPress environment. That means examples
can call WordPress APIs, not only plain PHP functions.

For example, a documentation page can demonstrate the HTML 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.:

    ```wp-block-code
    <php-snippet name="lazy-load-images.php">
        <script type="application/x-php">
    <?php
    require '/wordpress/wp-load.php';

    $html = '<article>
        <img src="hero.jpg" alt="Hero">
        <img src="inline.jpg" alt="Inline">
    </article>';

    $tags = new WP_HTML_Tag_Processor( $html );
    while ( $tags->next_tag( 'img' ) ) {
        $tags->set_attribute( 'loading', 'lazy' );
        $tags->add_class( 'responsive' );
    }

    echo $tags->get_updated_html();
        </script>
    </php-snippet>
    ```

That changes the role of code examples in WordPress documentation. Instead of asking
readers to copy code into a local site, the example can run where they are already
reading.

## PHP-only mode

Not every example needs WordPress. For plain PHP language features, snippets can
skip the WordPress download entirely:

    ```wp-block-code
    <php-snippet name="just-php.php" wp="none">
        <script type="application/x-php">
    <?php
    echo "PHP " . phpversion() . "\n";
    echo "WordPress installed: " .
        ( file_exists( '/wordpress/wp-includes/version.php' ) ? 'yes' : 'no' );
        </script>
    </php-snippet>
    ```

Under the hood, this maps to the new Blueprint option:

    ```wp-block-code
    {
        "preferredVersions": {
            "php": "latest",
            "wp": false
        }
    }
    ```

When `preferredVersions.wp` is `false`, Playground boots PHP without downloading
or installing WordPress. WordPress-specific Blueprint fields and steps are rejected,
which keeps PHP-only examples explicit and predictable.

## From demo page to documentation guide

The snippets work also moves beyond the original test/demo page. The PHP snippets
guide is becoming the canonical reference for this feature, with live-rendered examples
alongside copyable code.

That matters because the guide can show the feature in the same shape that authors
will use it: basic embeds, precomputed output, selector-based snippets, WordPress
snippets, pure PHP snippets, and option-by-option usage. The old demo page redirects
readers to the guide, and the component’s attribution link points there too.

## How to use it

Add the module script once on the page, then place each example in a `<php-snippet
>` element. The recommended pattern is to put PHP inside a child `<script type="
application/x-php">` element when the surrounding document is HTML, MDX, or another
format that will deliver the PHP code to the browser unchanged:

    ```wp-block-code
    <php-snippet name="site-title.php">
        <script type="application/x-php">
    <?php
    require '/wordpress/wp-load.php';

    update_option( 'blogname', 'Snippet Docs' );
    echo get_bloginfo( 'name' );
        </script>
        <script type="text/expected-output">
    Snippet Docs
        </script>
    </php-snippet>
    ```

The `application/x-php` wrapper is useful because browsers ignore unknown script
types. That lets authors include PHP strings containing HTML without escaping every`
<` character.

For very short examples, inline text works too, but the PHP opening tag must be 
escaped:

    ```wp-block-code
    <php-snippet name="sum.php" expected-output="42">
        &lt;?php echo 20 + 22;
    </php-snippet>
    ```

### Show output before Run

Use expected output when you want the result visible immediately. The placeholder
is replaced by the real runtime output after the reader clicks Run.

    ```wp-block-code
    <php-snippet name="precomputed.php">
        <script type="application/x-php">
    <?php
    echo "2 + 2 = " . ( 2 + 2 );
        </script>
        <script type="text/expected-output">
    2 + 2 = 4
        </script>
    </php-snippet>
    ```

For one-line output, use the `expected-output` attribute:

    ```wp-block-code
    <php-snippet name="ready.php" expected-output="Ready">
        <script type="application/x-php">
    <?php echo "Ready";
        </script>
    </php-snippet>
    ```

### Prepare examples with a Blueprint

Use `blueprint` when snippets need to be set up before the PHP code runs. The Blueprint
can create files, add a mu-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/](https://wordpress.org/plugins/)
or can be cost-based plugin from a third-party., configure options, install plugins,
or prepare sample content.

    ```wp-block-code
    <script id="setup-blueprint" type="application/json">
    {
        "steps": [
            {
                "step": "writeFile",
                "path": "/wordpress/wp-content/mu-plugins/helpers.php",
                "data": "<?php\nfunction docs_greet($name) { return 'Hello, ' . $name; }\n"
            }
        ]
    }
    </script>

    <php-snippet name="greeting.php" blueprint="setup-blueprint">
        <script type="application/x-php">
    <?php
    require '/wordpress/wp-load.php';
    echo docs_greet( 'Ada' );
        </script>
        <script type="text/expected-output">
    Hello, Ada
        </script>
    </php-snippet>
    ```

The `blueprint` attribute accepts an element id or a CSSCSS CSS is an acronym for
cascading style sheets. This is what controls the design or look and feel of a site.
selector. Use `<script type="application/json">` for the Blueprint because its contents
are treated as raw text, which keeps embedded PHP strings predictable.

### Load PHP from another file

Use `src` when the PHP source should live in a separate file:

    ```wp-block-code
    <php-snippet
        name="external-example.php"
        src="/snippets/external-example.php"
        expected-output="Loaded from an external file"
    ></php-snippet>
    ```

The URLURL A specific web address of a website or web page on the Internet, such
as a website’s URL www.wordpress.org resolves from the page that contains the snippet.
If the PHP file is hosted on another origin, that server needs to allow cross-origin
access. Use a Blueprint instead when the example needs support files, plugins, options,
or other setup.

### Pin versions or self-host the runtime

The default PHP version is `8.4`, and the default WordPress version is `latest`.
Use the `php` and `wp` attributes when the example depends on a specific version:

    ```wp-block-code
    <php-snippet name="wp-version.php" php="8.4" wp="6.8">
        <script type="application/x-php">
    <?php
    require '/wordpress/wp-load.php';
    echo get_bloginfo( 'version' );
        </script>
    </php-snippet>
    ```

Most pages should use the hosted runtime from `https://playground.wordpress.net`.
For local development, self-hosting, or pinned infrastructure, use `playground-origin`:

    ```wp-block-code
    <php-snippet
        name="local-runtime.php"
        playground-origin="http://localhost:5400"
    >
        <script type="application/x-php">
    <?php
    echo phpversion();
        </script>
    </php-snippet>
    ```

## More control for authors

The snippet component includes a few authoring tools that make it practical for 
real documentation:

 * Snippets are editable by default, so readers can change the code before running
   it.
 * Use `Ctrl+Enter` or `Cmd+Enter` to run a focused editable snippet from the keyboard.
 * Use `readonly` for runnable examples that should stay locked.
 * Use `editable="false"` as a compatibility alias for older examples that already
   use that pattern.
 * Use `src` to load PHP from a separate file.
 * Use `expected-output` or a `<script type="text/expected-output">` child to show
   expected output before the reader clicks Run.
 * Use `runnable="false"` for syntax-highlighted examples that should not execute.
 * Use `php` and `wp` attributes to choose the PHP and WordPress versions for a 
   snippet.
 * Use a shared Blueprint when multiple snippets need the same setup, such as a 
   mu-plugin, site option, or file.

That last point is especially useful for longer tutorials. A page can define one
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. Blueprint and point several snippets at it.
Playground boots the shared environment once, then each snippet runs against the
same prepared runtime.

## Runtime sharing and troubleshooting

The first run clicks on a page, loads the Playground client, creates a hidden iframe,
boots PHP, and installs WordPress unless the snippet uses `wp="none"`. Later runs
reuse an existing runtime when `playground-origin`, `php`, `wp`, and the resolved
Blueprint JSON all match.

That sharing keeps related snippets fast while still isolating examples that need
a different PHP version, WordPress version, or setup Blueprint.

If a snippet does not render, check that the module script is loaded and that the
browser supports custom elements. If Run never finishes, open DevTools and look 
for failed requests to `remote.html`, PHP `.wasm` files, WordPress zip files, Blueprint
resources, or cross-origin `src` files.

Sites with a strict Content Security Policy need to allow the module script and 
hidden iframe from `https://playground.wordpress.net`, plus the runtime assets that
Playground downloads. For stricter environments, self-host the snippet script and
point `playground-origin` at that deployment.

## Standalone PHP Playground

For full-page examples, Playground also includes a standalone PHP editor:

[playground.wordpress.net/php-playground.html](https://playground.wordpress.net/php-playground.html)

It provides a side-by-side editor and preview with PHP and WordPress version selectors.
The current code and version choices are encoded in the URL fragment, so examples
can be shared as links or embedded in an iframe.

Use the standalone editor for a single larger demo. Use `<php-snippet>` when a post,
handbook page, or tutorial needs several small runnable examples inline.

## Why this matters

Runnable snippets make Playground useful in a new layer of the WordPress learning
experience.

For doc authors, it reduces the gap between explanation and verification. A reader
can run the example immediately.

For contributors, it creates a low-friction way to demonstrate WordPress APIs, PHP
behavior, Blueprint setup steps, or bug reproductions.

For learners, it removes the setup barrier. They can try PHP and WordPress code 
in the browser first, then move to a local environment when they are ready.

This also broadens the meaning of Playground. It is still a full WordPress runtime
in the browser, but it can now act as a small, embeddable PHP execution layer for
the web.

## Try it and share feedback

Try the snippet embed in a local HTML file, a documentation page, or a tutorial 
draft:

    ```wp-block-code
    <script
        type="module"
        src="https://playground.wordpress.net/php-code-snippet.js"
    ></script>
    ```

For deeper examples, see the new PHP snippets guide in the Playground documentation:

[PHP code snippets and embeds](https://wordpress.github.io/wordpress-playground/guides/php-code-snippets)

Feedback is welcome in the **[#playground](https://make.wordpress.org/playground/tag/playground/)**
channel on [Making WordPress Slack](https://make.wordpress.org/chat/) or in the 
[WordPress Playground GitHub repository](https://github.com/WordPress/wordpress-playground/issues).

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F05%2F19%2Frun-php-examples-anywhere-with-wordpress-playground%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
1:29 pm _on_ May 11, 2026      

# 󠀁[Playground Meetings Summaries – April 2026](https://make.wordpress.org/playground/2026/05/11/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](https://profiles.wordpress.org/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](https://central.wordcamp.org/about/).
   Asia 2026** was still running during the meeting. Talks were available via [livestream](https://asia.wordcamp.org/2026/).
   Thanks to @dilipmodhavadiya, @gauravbhai, @rimaprajapati, [@shailmehta](https://profiles.wordpress.org/shailmehta/),
   and [@arslan](https://profiles.wordpress.org/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/](https://make.wordpress.org/)
   There are many teams that people can participate in, each with a different focus.
   [https://make.wordpress.org/support/handbook/getting-started/getting-started-at-a-contributor-day/](https://make.wordpress.org/support/handbook/getting-started/getting-started-at-a-contributor-day/)
   table.
 * [@Bero](https://profiles.wordpress.org/bero/) published a new Agent Skill to 
   help coding agents write Blueprints. Read the announcement: [Teach your coding agent to write WordPress Playground Blueprints](https://make.wordpress.org/playground/2026/04/02/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/](https://wordpress.org/) Handbook format.
   Read the announcement: [Migrating WordPress Playground Documentation to WordPress.org](https://make.wordpress.org/playground/2026/04/07/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/index.php](https://www.php.net/manual/en/index.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](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](https://profiles.wordpress.org/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/](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](https://profiles.wordpress.org/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](https://profiles.wordpress.org/bpayton/)** — Focused on Playground 
CLI performance improvements and reviewing pull requests. There is still a backlog
of pull requests awaiting review.

**[@janjakes](https://profiles.wordpress.org/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](https://profiles.wordpress.org/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](https://profiles.wordpress.org/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](https://profiles.wordpress.org/bph/). New translations landed
in Gujarati, Portuguese, Spanish, and French.

Thanks to [@shailmehta](https://profiles.wordpress.org/shailmehta/), [@shimomura](https://profiles.wordpress.org/shimomura/),
[@b](https://profiles.wordpress.org/b/)éryl, @ydecat, and [@nilovelez](https://profiles.wordpress.org/nilovelez/)
for the translation contributions.

### Contributor updates

**[@fellyph](https://profiles.wordpress.org/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](https://profiles.wordpress.org/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](https://profiles.wordpress.org/mosescursor/)** — Recently focused
on organizing WordCamp Asia and contributing to other teams. Now available to contribute
to Playground again.

**[@janjakes](https://profiles.wordpress.org/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](https://github.com/WordPress/sqlite-database-integration/pull/358))
 * Improve concurrent database access ([#361](https://github.com/WordPress/sqlite-database-integration/pull/361))
 * Support MySQL `BINARY` operator ([#369](https://github.com/WordPress/sqlite-database-integration/pull/369))
 * Add support for `AUTO_INCREMENT` value management ([#367](https://github.com/WordPress/sqlite-database-integration/pull/367))
 * Add support for `DELETE` with `LIMIT` and `ORDER BY` ([#365](https://github.com/WordPress/sqlite-database-integration/pull/365))
 * Add Query Monitor 4.0 support ([#357](https://github.com/WordPress/sqlite-database-integration/pull/357))
 * Translate MySQL `CONVERT()` expressions to SQLite ([#356](https://github.com/WordPress/sqlite-database-integration/pull/356))

**[@bpayton](https://profiles.wordpress.org/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/](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](https://wordpress.slack.com/archives/C07S16PNS)
SlackSlack Slack is a Collaborative Group Chat Platform [https://slack.com/](https://slack.com/).
The WordPress community has its own Slack Channel at [https://make.wordpress.org/chat/](https://make.wordpress.org/chat/)
channel. All are welcome._

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F05%2F11%2Fplayground-meetings-summaries-april-2026%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
9:42 am _on_ April 2, 2026     
Tags: agent-skills, [ai ( 2 )](https://make.wordpress.org/playground/tag/ai/),
[playground ( 7 )](https://make.wordpress.org/playground/tag/playground/)   

# 󠀁[Teach your coding agent to write WordPress Playground Blueprints](https://make.wordpress.org/playground/2026/04/02/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:

    ```wp-block-code
    npx skills add wordpress/agent-skills --skill blueprint
    ```

Or install manually by cloning the [agent-skills repository](https://github.com/WordPress/agent-skills)
and running the build script:

    ```wp-block-code
    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/](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:**

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

**Generated Blueprint:**

    ```wp-block-code
    {
      "$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](https://
make.wordpress.org/playground/files/2026/04/playground-developer-plugin-blueprint-
1024x695.webp)

### 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/](https://wordpress.org/plugins/)󠁿 or can be cost-based plugin from a third-party. from a GitHub branch

**Prompt:**

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

**Generated Blueprint:**

    ```wp-block-code
    {
      "$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:**

    ```wp-block-code
    Create a Blueprint for a WooCommerce store with 5 sample products
    across 2 categories, running on PHP 8.2.
    ```

**Generated Blueprint:**

    ```wp-block-code
    {
      "$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.](https://
make.wordpress.org/playground/files/2026/04/woo-store-blueprint-1024x695.webp)

### 4. Inline mu-plugin for custom behavior

**Prompt:**

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

**Generated Blueprint:**

    ```wp-block-code
    {
      "$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:**

    ```wp-block-code
    Create a Blueprint bundle that installs a custom analytics plugin
    from a local zip file.
    ```

**Generated bundle structure:**

    ```wp-block-code
    analytics-bundle/
    ├── blueprint.json
    └── analytics-plugin.zip
    ```

**blueprint.json:**

    ```wp-block-code
    {
      "$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:**

    ```wp-block-code
    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](https://wordpress.github.io/wordpress-playground/guides/agent-skill-wp-playground)** | Runs CLI commands, manages servers, debugs instances | When you need a running Playground instance with live interaction | 
| **[MCP server](https://make.wordpress.org/playground/2026/03/17/connect-ai-coding-agents-to-wordpress-playground-with-mcp/)** | Connects agents directly to a browser Playground | When you need real-time PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. [https://www.php.net/manual/en/index.php](https://www.php.net/manual/en/index.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:

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

### Local CLI (full test)

    ```wp-block-code
    # 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:

    ```wp-block-code
    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](https://make.wordpress.org/playground/tag/playground/)**
channel on [Making WordPress Slack](https://make.wordpress.org/chat/) or open an
issue on [GitHub](https://github.com/WordPress/agent-skills/issues).

[#agent-skills](https://make.wordpress.org/playground/tag/agent-skills/), [#ai](https://make.wordpress.org/playground/tag/ai/)

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F04%2F02%2Fteach-your-coding-agent-to-write-wordpress-playground-blueprints%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
11:53 am _on_ March 30, 2026      

# 󠀁[Playground Meetings Summaries – March 2026](https://make.wordpress.org/playground/2026/03/30/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](https://profiles.wordpress.org/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](https://wordpress.github.io/wordpress-playground/)—
   Introduces the new `start` command, designed to simplify local WordPress environment
   setup.
 * [How WordPress Playground cut PHP.wasm binary sizes by 122 MB](https://wordpress.github.io/wordpress-playground/)—
   Covers two compiler flag changes that reduced PHP.wasm binary sizes from 888 
   MB to 766 MB.

**WordPress 7.0 betaBeta A pre-release of software that is given out to a large 
group of users to trial under real conditions. Beta versions have gone through alpha
testing in-house and are generally fairly close in look, feel and function to the
final product; however, design changes often occur as part of the process. 5** is
available for testing on Playground. Contributors are encouraged to test their plugins
and themes ahead of the next WordPress release at [playground.wordpress.net/?wp=beta](https://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](https://2026.wasm.io/speakers/fellyph-cintra/) 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/index.php](https://www.php.net/manual/en/index.php)-
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](https://wordpress.github.io/wordpress-playground/guides/e2e-testing-with-playwright/)
 * [Programmatic Usage of Playground CLI](https://wordpress.github.io/wordpress-playground/guides/programmatic-playground-cli/)

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/](http://wp-cli.org/)
[https://make.wordpress.org/cli/](https://make.wordpress.org/cli/)-style workflows.
The testing suite now uses local PHARs to remove external download dependencies.

**[@fellyph](https://profiles.wordpress.org/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](https://profiles.wordpress.org/fellyph/).

### Announcements

**MCP Server post published** — The post [Connect AI coding agents to WordPress Playground with MCP](https://wordpress.github.io/wordpress-playground/)
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](https://profiles.wordpress.org/ashfame/)
and [@zaerl](https://profiles.wordpress.org/zaerl/) for looking into the reported
issues.

#### Website PRs

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

#### CLI PRs

The CLI now automatically restarts with JSPI support enabled, without manual Node
flags ([#3281](https://github.com/WordPress/wordpress-playground/pull/3281)), and
uses a faster built-in method for process checking during temp directory cleanup(
[#3395](https://github.com/WordPress/wordpress-playground/pull/3395)). Additional
improvements include module-boundary linting ([#3410](https://github.com/WordPress/wordpress-playground/pull/3410)),
a new Playwright-based benchmarking suite for site editor startup and interaction
times ([#3408](https://github.com/WordPress/wordpress-playground/pull/3408)), and
silencing harmless streaming errors caused by client disconnects ([#3397](https://github.com/WordPress/wordpress-playground/pull/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/](https://github.com/)
Releases are now auto-generated after every npm publish ([#3429](https://github.com/WordPress/wordpress-playground/pull/3429),
[#3430](https://github.com/WordPress/wordpress-playground/pull/3430)). The Claude
agent’s permissions have been hardened: `rm` commands are now blocked ([#3398](https://github.com/WordPress/wordpress-playground/pull/3398)),
and allow/deny lists have been updated to prevent destructive actions while permitting
read-only git operations ([#3373](https://github.com/WordPress/wordpress-playground/pull/3373)).
Dependabot’s config was also fixed to properly exclude directories ([#3426](https://github.com/WordPress/wordpress-playground/pull/3426)).

#### SQLite

 * [#3428](https://github.com/WordPress/wordpress-playground/pull/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/](https://wordpress.org/plugins/)
   or can be cost-based plugin from a third-party..
 * [#3435](https://github.com/WordPress/wordpress-playground/pull/3435) — Reverted
   that path update.

#### PHP-WASM

 * [#3417](https://github.com/WordPress/wordpress-playground/pull/3417) — Fixed 
   Redis extension corruption in WASM32 caused by a variadic ABI mismatch.
 * [#3399](https://github.com/WordPress/wordpress-playground/pull/3399) — Fixed 
   a race condition in `proc_open` where pipe writes could crash after streams were
   already closed.

### Updates from contributors

**[@fellyph](https://profiles.wordpress.org/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](https://profiles.wordpress.org/brandonpayton/) and [@ashfame](https://profiles.wordpress.org/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](https://profiles.wordpress.org/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](https://profiles.wordpress.org/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](https://profiles.wordpress.org/janjakes/)** — Back to SQLite work,
focusing on monorepo setup, automation, and the upcoming v3 release.

### Open floor

[@fellyph](https://profiles.wordpress.org/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_.

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F03%2F30%2Fplayground-meetings-summaries-march-2026%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
11:02 am _on_ March 17, 2026     
Tags: [ai ( 2 )](https://make.wordpress.org/playground/tag/ai/),
[playground ( 7 )](https://make.wordpress.org/playground/tag/playground/)   

# 󠀁[Connect AI coding agents to WordPress Playground with MCP](https://make.wordpress.org/playground/2026/03/17/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/index.php](https://www.php.net/manual/en/index.php),
and manage sites directly in your browser? The `[@wp-playground/mcp](https://www.npmjs.com/package/@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.

    ```wp-block-code
    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

    ```wp-block-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.

### Codex

Codex supports stdio MCP servers through the `codex mcp` command. Add WordPress 
Playground as a user-level MCP server with:

    ```wp-block-code
    codex mcp add wordpress-playground -- npx -y @wp-playground/mcp
    ```

Then ask Codex to open the Playground site. The MCP server provides the exact Playground
URL when it connects, including the local `mcp-port` parameter needed to link the
browser tab to the MCP server.

### 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):

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

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/](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:

    ```wp-block-code
    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](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](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/](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](https://www.npmjs.com/package/@wp-playground/mcp#available-tools):

 * **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](https://make.wordpress.org/playground/tag/playground/)** 
channel on [Making WordPress Slack](https://make.wordpress.org/chat/) or open an
issue on [GitHub](https://github.com/WordPress/wordpress-playground/issues) to suggest
new tools.

Props to [@berislavgrgicak](https://profiles.wordpress.org/berislavgrgicak/) for
building the MCP server and reviewing the post.
[#ai](https://make.wordpress.org/playground/tag/ai/)
[#playground](https://make.wordpress.org/playground/tag/playground/)

[[+make.wordpress.org/core/ 
[](https://make.wordpress.org/ai/)+make.wordpress.org/
ai/

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F03%2F17%2Fconnect-ai-coding-agents-to-wordpress-playground-with-mcp%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
6:35 pm _on_ March 11, 2026      

# 󠀁[How WordPress Playground cut PHP.wasm binary sizes by 122 MB](https://make.wordpress.org/playground/2026/03/11/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/index.php](https://www.php.net/manual/en/index.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](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](https://github.com/WordPress/wordpress-playground/pull/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](https://emscripten.org/docs/porting/asyncify.html).
 * **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](https://v8.dev/blog/jspi).

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

 * PR [#3332](https://github.com/WordPress/wordpress-playground/pull/3332) targeted
   JSPI builds.
 * PR [#3335](https://github.com/WordPress/wordpress-playground/pull/3335) completed
   the same change for Asyncify builds.

## The numbers

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

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

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

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

## Why smaller binaries matter

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

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

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

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

## What this means for `php-wasm` packages

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

## What comes next

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

Props to [@mho22](https://github.com/mho22) for implementing both PRs and reviewing
the post, [@brandonpayton](https://github.com/brandonpayton) for reviewing, and 
[@adamziel](https://github.com/adamziel) for the architectural direction. See the
full details in [PR #3332](https://github.com/WordPress/wordpress-playground/pull/3332)
and [PR #3335](https://github.com/WordPress/wordpress-playground/pull/3335).

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F03%2F11%2Fhow-wordpress-playground-cut-php-wasm-binary-sizes-by-122-mb%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
12:22 pm _on_ March 3, 2026      

# 󠀁[Playground Meetings Summaries – February 2026](https://make.wordpress.org/playground/2026/03/03/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](https://make.wordpress.org/playground/2026/02/06/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)](https://developer.wordpress.org/news/2026/02/whats-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](https://github.com/WordPress/wordpress-playground/pull/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](https://github.com/WordPress/wordpress-playground/pull/3242) — Updates
   the “Host Your Own Playground” self-hosting page with current instructions and
   improved clarity.
 * [#3103](https://github.com/WordPress/wordpress-playground/pull/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](https://profiles.wordpress.org/noruzzaman/)
and [@shimomura](https://profiles.wordpress.org/shimomura/) tomoki for their contributions.

 * [#3177](https://github.com/WordPress/wordpress-playground/pull/3177) — Updates`
   translations.md` for multiple languages.
 * [#3249](https://github.com/WordPress/wordpress-playground/pull/3249), [#3230](https://github.com/WordPress/wordpress-playground/pull/3230),
   [#3229](https://github.com/WordPress/wordpress-playground/pull/3229), [#3231](https://github.com/WordPress/wordpress-playground/pull/3231)—
   Bengali translations for several guides and documentation pages.
 * [#3228](https://github.com/WordPress/wordpress-playground/pull/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/index.php](https://www.php.net/manual/en/index.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](https://profiles.wordpress.org/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/](https://slack.com/). The WordPress community
has its own Slack Channel at [https://make.wordpress.org/chat/](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/](https://wordpress.org/gutenberg/) v22.6.0.
Two related pull requests are in progress:

 * [#3312](https://github.com/WordPress/wordpress-playground/pull/3312) — Avoids
   cross-origin policy errors in the editor.
 * [#3301](https://github.com/WordPress/wordpress-playground/pull/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](https://make.wordpress.org/playground/2026/02/24/simplify-your-workflow-with-the-new-playground-cli-start-command/)
 * [Manage your database directly from the Playground CLI](https://make.wordpress.org/playground/2026/02/20/manage-your-database-directly-from-the-playground-cli/)

WordPress 7.0 Beta 2 is now available for testing on [WordPress Playground](https://playground.wordpress.net/?php=8.0&wp=beta).
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/](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](https://github.com/WordPress/wordpress-playground/pull/3288) — Removes
   a duplicated “Playground CLI Ready” log line to keep startup output clean.
 * [#3238](https://github.com/WordPress/wordpress-playground/pull/3238) — Detects“
   port already in use” errors and returns a clear, actionable message.
 * [#3150](https://github.com/WordPress/wordpress-playground/pull/3150) — Fixes 
   Windows native file-locking issues in the multi-threaded CLI architecture.

_PHP.wasm_

 * [#3287](https://github.com/WordPress/wordpress-playground/pull/3287) — Adds PHP
   function names and refactors the test suite to improve coverage and maintainability.
 * [#3234](https://github.com/WordPress/wordpress-playground/pull/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](https://profiles.wordpress.org/noruzzaman/)
and [@shimomura](https://profiles.wordpress.org/shimomura/) tomoki for their continued
contributions.

_Documentation_

 * A new guide is available: [Using the WordPress Playground Agent Skill](https://wordpress.github.io/wordpress-playground/guides/agent-skill-wp-playground).
 * Following feedback from the previous meeting, `CLAUDE.md` has been migrated to`
   AGENTS.md`.

### Updates from contributors

 * **Fellyph Cintra** — Migrating the documentation to the `.org` Handbook, working
   on the Agent Skill guide and the two CLI posts. Started testing Playground with
   Claude Code and Gemini HooksHooks In WordPress theme and development, hooks are
   functions that can be applied to an action or a Filter in WordPress. Actions 
   are functions performed when a certain event occurs in WordPress. Filters allow
   you to modify certain functions. Arguments used to hook both filters and actions
   look the same.; a post about it is coming soon.
 * **Jan Jakes ([@janjakes](https://profiles.wordpress.org/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](https://wordpress.slack.com/archives/C07S16PNS)
Slack channel. All are welcome to join._

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F03%2F03%2Fplayground-meetings-summaries-february-2026%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
6:41 pm _on_ February 24, 2026      

# 󠀁[Simplify your workflow with the new Playground CLI start command](https://make.wordpress.org/playground/2026/02/24/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/](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](https://github.com/WordPress/wordpress-playground/pull/3040)),
you can launch a local WordPress instance more intuitively.

Instead of configuring complex parameters, you can now run:

    ```wp-block-code
    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](https://github.com/WordPress/wordpress-playground/pull/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:

    ```wp-block-code
    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/index.php](https://www.php.net/manual/en/index.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](https://wordpress.github.io/wordpress-playground/developers/05-local-development/04-wp-playground-cli).

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F02%2F24%2Fsimplify-your-workflow-with-the-new-playground-cli-start-command%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
11:21 am _on_ February 20, 2026      

# 󠀁[Manage your database directly from the Playground CLI](https://make.wordpress.org/playground/2026/02/20/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/](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/index.php](https://www.php.net/manual/en/index.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:

    ```wp-block-code
    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:

    ```wp-block-code
    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:

![](https://make.wordpress.org/playground/files/2026/02/playground-cli-phpmyadmin-
1024x695.webp)

## Custom URL path

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

    ```wp-block-code
    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

    ```wp-block-code
    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

    ```wp-block-code
    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

    ```wp-block-code
    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:

    ```wp-block-code
    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/](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](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](https://github.com/WordPress/wordpress-playground/pull/2926).
If you run into issues or have suggestions, share them on the [Making WordPress Slack](https://make.wordpress.org/chat/)
or open an issue on [GitHub](https://github.com/WordPress/wordpress-playground/issues).

Props to [@JanJakes](https://github.com/JanJakes) for reviewing this post.

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F02%2F20%2Fmanage-your-database-directly-from-the-playground-cli%2F%23respond&locale=en_US)

 [  ](https://profiles.wordpress.org/fellyph/) [Fellyph Cintra](https://profiles.wordpress.org/fellyph/)
11:33 am _on_ January 28, 2026     
Tags: [meeting ( 3 )](https://make.wordpress.org/playground/tag/meeting/)

# 󠀁[WordPress Playground Team Meeting Summary: January 23, 2026](https://make.wordpress.org/playground/2026/01/28/wordpress-playground-team-meeting-summary-january-23-2026/)󠁿

**Facilitator:** [@fellyph](https://profiles.wordpress.org/fellyph/)

The Playground team held its weekly meeting on January 23, 2026, in the  [#playground](https://wordpress.slack.com/archives/playground)
SlackSlack Slack is a Collaborative Group Chat Platform [https://slack.com/](https://slack.com/).
The WordPress community has its own Slack Channel at [https://make.wordpress.org/chat/](https://make.wordpress.org/chat/)
channel. Here’s a summary of the discussion.

### Announcements

**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/index.php](https://www.php.net/manual/en/index.php)
version support update:** WordPress Playground has dropped support for PHP 7.2 and
7.3. While this change is scheduled for WordPress 7.0, Playground has implemented
it early. See the [Playground blog](https://make.wordpress.org/playground/2026/01/16/wordpress-playground-removes-support-for-php-7-2-and-7-3/)
for details.

**AI agent skills:** [@bpayton](https://profiles.wordpress.org/bpayton/) has created
an [Agent Skill](https://github.com/WordPress/agent-skills) for testing WordPress
applications on Playground. An announcement post is in progress. The team encourages
community testing and contributions. Additionally, [Automattic has released a set of Agent Skills](https://github.com/Automattic/agent-skills),
including one for Playground.

**Newsletter:** The Playground blog now offers a newsletter subscription. Sign up
via the form on the blog sidebarSidebar A sidebar in WordPress is referred to a 
widget-ready area used by WordPress themes to display information that is not a 
part of the main content. It is not always a vertical column on the side. It can
be a horizontal rectangle below or above the content area, footer, header, or any
where in the theme. to receive updates.

**Contributors:** The Playground project now has 53 members with the [Playground Contributor Badge](https://wordpress.github.io/wordpress-playground/contributing/contributor-badge).

**Translations:** Thanks to [@noruzzaman](https://profiles.wordpress.org/noruzzaman/)
for submitting Bengali pages and [@B](https://profiles.wordpress.org/b/)éryl for
reviewing French translations. Contact [@fellyph](https://profiles.wordpress.org/fellyph/)
if you want to get involved.

### Project Updates

 * **Personal Playground:** [@akirk](https://profiles.wordpress.org/akirk/) is developing
   Personal Playground, a new feature currently in review. Feedback is welcome on
   the PR.
 * **PHP synchronous connect():** A PR simplifies connection logic for Asyncify 
   builds by replacing asynchronous approaches with synchronous connections.
 * **Node.js upgrade:** The project has upgraded from Node.js 20 to 22, enabling
   package updates.
 * **Agent documentation:** The project has added a CLAUDE.md file. The team discussed
   renaming it to `AGENTS.md` for broader compatibility with tools like Gemini CLICLI
   Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or
   WP-CLI for WordPress., Cursor, and Copilot. The proposed solution is to use `
   AGENTS.md` as the main file with `CLAUDE.md` referencing it.
 * **Image optimization:** [@fellyph](https://profiles.wordpress.org/fellyph/) updated
   all PNG images in the documentation to WebP, reducing image sizes by 78%.

### Updates from Contributors

 * [@zieladam](https://profiles.wordpress.org/zieladam/)**:** Helping [@akirk](https://profiles.wordpress.org/akirk/)
   review and merge the “My WordPress” project before February. Shipped Redis and
   Memcached extensions and added native DNSDNS DNS is an acronym for Domain Name
   System - how you assign a human readable address to a website’s exact numeric
   coded location (ie. wordpress.org uses the actual IP address 198.143.164.252).
   resolution for the JSPI Node.js flavor of Playground.
 * **[@fellyph](https://profiles.wordpress.org/fellyph/):** Working on CSSCSS CSS
   is an acronym for cascading style sheets. This is what controls the design or
   look and feel of a site. improvements and CSS tokens for the Playground website.
   Created a PR to add translation credit footers.
 * **[@bph](https://profiles.wordpress.org/bph/):** Published two blog posts for
   theme developers:
    - [How to Build an Interactive WordPress Theme Demo with Playground Blueprints](https://wordpress.com/blog/)(
      WordPress.comWordPress.com An online implementation of WordPress code that
      lets you immediately access a new WordPress environment to publish your content.
      WordPress.com is a private company owned by Automattic that hosts the largest
      multisite in the world. This is arguably the best place to start blogging 
      if you have never touched WordPress before. [https://wordpress.com/](https://wordpress.com/)
      blog)
    - [Streamlining block theme development with WordPress Playground and GitHub](https://developer.wordpress.com/blog/)(
      Developer blog)
 * **[@bpayton](https://profiles.wordpress.org/bpayton/):** Working on stabilizing
   the experimental multi-workers feature to remove the “experimental” flag and 
   improve default performance.

### Open Floor

The team briefly discussed CSS tokens and whether anyone has used the CSS tokens
from `@wordpress/theme`.

The next Playground meeting is scheduled for the 13th of February 2026. Join the
conversation at [#playground](https://wordpress.slack.com/archives/playground) Slack
channel.

[#meeting](https://make.wordpress.org/playground/tag/meeting/)

 * [Login to Reply](https://login.wordpress.org/?redirect_to=https%3A%2F%2Fmake.wordpress.org%2Fplayground%2F2026%2F01%2F28%2Fwordpress-playground-team-meeting-summary-january-23-2026%2F%23respond&locale=en_US)

## Post navigation

[← Older posts](https://make.wordpress.org/playground/page/3/?replies=none&output_format=md)

[Newer posts →](https://make.wordpress.org/playground/?replies=none&output_format=md)