Can the technology behind WordPress Playground help other 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 projects run in the browser?

Joomla contributor Herman Peeren is exploring that with Joomla Playground, an early community project that runs Joomla in a browser tab. You can explore its administrator and frontend without installing a local PHP server or setting up a database.

For me, the interesting part is what this brings back to the shared tools. Joomla introduces different queries, workloads, and assumptions, revealing compatibility and performance lessons that contributors can investigate together.

What Joomla Playground shares with WordPress

The project builds on two components from the WordPress ecosystem.

The first is PHP.wasm. Joomla Playground uses the @php-wasm packages developed in the WordPress Playground repository to run PHP as WebAssembly in the browser. Joomla’s files and database also operate locally. The second is wordpress/mysql-on-sqlite. A Joomla-specific adapter connects its 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 driver to this library, allowing MySQL queries to execute against SQLite. You can inspect that connection in the database adapter.

The browser architecture follows a familiar pattern: a worker runs PHP, a service worker routes requests, and an 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. displays the CMS. Joomla adds its own startup logic, configuration, and Blueprint steps around that foundation.

Exploring Joomla without a local setup

Open Joomla Playground in a recent Chromium browser, such as Chrome or Edge. It starts a temporary site and automatically signs you in to the administrator. The toolbar lets you switch between the administrator and the public site. The project’s guide documents Joomla 6.2 and 5.4, with PHP 8.3, 8.4, and 8.5. It also describes controls for saving a site in your browser, importing and exporting ZIP files, and inspecting captured email without delivering it. Project guide

I suggest exploring the multilingual Heritage demo. A Joomla-specific 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 prepares content in English, Dutch, German, French, and Spanish, using demonstration data from Clifford E Ford. If you are preparing a workshop or demonstration, pay attention to persistence. Temporary sites disappear when you reload the page or close the tab. Saving keeps the site in that browser; exporting gives you a copy you can move elsewhere.

Lessons from running another CMS

Herman’s report provides concrete findings for contributors to explore. His tests included PHP.wasm 3.1.60 and MySQL-on-SQLite 3.1.1, so these observations are starting points for reproduction against current upstream code.

SQL compatibility

Joomla exercised SQL behavior that needed additional handling, including prepared statements, missing functions, server variables, and binary comparisons. One case affected login: session identifiers stored as binary values did not match the string comparisons Joomla used to retrieve them. Herman added local workarounds in the database adapter.

These cases could become regression tests for the shared database library. That is a practical benefit of testing another application: it exposes behavior that WordPress alone may not exercise.

Faster browser saves

Saving thousands of individual files to browser storage proved expensive. Herman switched to a shared base ZIP plus a snapshot of changed files, using Playground’s filesystem journal to track modifications. In his local measurements, saving dropped from 13 seconds to approximately 0.3 seconds. The implementation also replaces snapshots atomically and uses a per-site lock to prevent competing writers. Storage implementation

My reading is that this approach deserves testing with WordPress workloads. Those figures describe Herman’s Joomla tests; they do not establish the same improvement for WordPress Playground.

Making the site usable sooner

Two other findings involved requests sharing a single PHP worker. An unavailable network connection could leave a request waiting for minutes, blocking those behind it. Background search indexing also repeatedly entered the queue ahead of page navigation.

Herman enabled PHP networking through browser fetch and split indexing into smaller batches that yield between requests. Deferring indexing roughly halved the Heritage demo’s reported time to become usable, while the toolbar showed the remaining work. Report, sections 13, 18, and 24

For someone opening a demo, the practical question is simple: when can I start using the site? These findings give contributors specific cases to investigate around network failures and background Blueprint work.

Learning across the PHP ecosystem

Joomla Playground shows how this collaboration can work in both directions. Shared infrastructure makes another CMS easier to explore, and that CMS brings integration experience that can help improve the infrastructure. For educators and community organizers, there is also an immediate benefit: people can explore the software before spending time configuring an environment.

Try Joomla Playground, explore Herman’s source code, and share reproducible findings in the issue tracker. Thank you to Herman, Milana, and the contributors across these projects for making this exchange possible.

Which PHP application would you like to explore in the browser, and what would you test first? Please go to the Playground Channel and share with the team.

Did your contact form generate the notification you expected? Was the right welcome message generated for a new user? WordPress Playground now gives you a way to inspect those emails while you test a site in your browser. Open Dev Tools → Email to see messages generated by the current Playground, without setting up a mail server or checking a real inbox.

The Email tool starts empty and shows messages generated by the current Playground.

How email capture works

When WordPress sends a message through its normal wp_mail() path, 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 writes it to a sendmail-compatible program. Playground captures that message in the browser instead of delivering it. The website parses the captured message and adds it to the Email panel for the current site. You can select a message to check its subject, sender, recipient, time, and body, including 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. preview when the message contains HTML.

The work arrived in stages: sendmail capture in PR #3996, forwarding captured messages to the website in PR #4103, and the Email viewer in PR #4000.

Try it in a fresh Playground

You can generate a sample message without installing a pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party.:

1. Open playground.wordpress.net and wait for WordPress to load.
2. Select Dev Tools in the Dock, then Email. A fresh site shows No emails yet.
3. Open Dev Tools → Terminal, select PHP, paste the snippet below, and select Run. The Terminal loads WordPress for you.

$sent = wp_mail( 'reader@example.invalid', 'Playground email test', 'Hello from WordPress Playground.' );echo $sent ? 'wp_mail() returned true' : 'wp_mail() returned false';

4. Return to Dev Tools → Email and select Playground email test. Check the recipient, subject, and message body. The message appears in Playground; nothing is delivered to reader@example.invalid.

You can also test a WordPress action instead of running PHP. For example, create a user under Users with Send the new user an email about their account selected, then inspect the generated messages. Once a plugin is installed, perform the action that normally sends its message and check the same panel. The Terminal guide has more on running PHP against the active site.

Which plugins benefit?

The Email tool is useful wherever a plugin sends messages through WordPress’s usual mail path:

• Forms: Submit a contact or lead form and check the notification’s recipient, subject, and submitted fields.
• Registration and membership: Check welcome, approval, invitation, and account messages after a user action.
• Commerce, bookings, and events: Inspect order, reservation, and confirmation emails while testing a workflow.
• Email templates and notifications: Compare generated text or HTML across settings, themes, and WordPress versions.

Plugin developers can offer a Playground demo that lets testers complete an action and inspect its email in the same browser session. Contributors and documentation authors can also use it to reproduce WordPress notification behavior without supplying a working mailbox.

What the Email tool does not test

A captured email is not a delivered email. Even when wp_mail() returns true, that only shows the message was accepted for processing; it does not prove that an external recipient received it. The Email panel helps you inspect messages sent through Playground’s sendmail capture path. A plugin that sends through a separate SMTP connection or provider 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. may bypass that path, so use an appropriate delivery test for those integrations.

Messages in the Email panel belong to the current Playground runtime session. Reloading the Playground website tab or reopening a saved site clears the captured messages, even though the WordPress site itself can persist. Wait for Playground to finish loading before triggering a test action; messages sent during initial Blueprint setup may not appear.

Try the feature on WordPress Playground. If a message does not appear, report the steps in the Playground repository, including the plugin or WordPress action you tested and whether it uses wp_mail() or another mail service.

WordPress Playground has shipped two new features: an integrated Terminal for 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 and WP-CLIWP-CLI WP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/ https://make.wordpress.org/cli/, and a group for developer tools options on the Dock. The compact Dock keeps the everyday actions in view while giving developers a direct path to the tools for inspecting and changing a site.

From the Terminal, you can inspect content, check configuration, test a WordPress 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., or make a quick change without setting up a local environment or leaving playground.wordpress.net. It runs against the active Playground, so a command reads or changes the same WordPress site visible behind the panel.

The New group for Developer Tools in the Dock

Visit playground.wordpress.net and wait for WordPress to start. The Dock at the bottom of the screen shows New, Playgrounds, Site Settings, Export, and Dev Tools. In its compact state, it hides the developer-facing buttons to give people exploring WordPress a simpler toolbar.

Select Dev Tools next to Export to expand the Dock. It reveals Blueprint, Database, Terminal, Files, Logs, and Email. Then select Terminal to open the runner for the current site.

Playground remembers whether the developer tools were shown or hidden across page reloads. Collapsing them keeps an unfinished Terminal or Blueprint draft, so you can reopen the tool and continue.

The other new feature is Terminal, which opens with two modes:

• PHP runs short PHP snippets with WordPress already loaded.
• WP-CLI runs WordPress command-line commands against the active site.

Each mode keeps its own input, results, and command history, so you can move between PHP and WP-CLI without losing your place.

Explore WordPress with PHP

PHP mode provides a syntax-highlighted editor with line numbers and a few ready-to-run examples. You can select examples such as Versions, Site URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org, List posts, Create post, or Active plugins, edit the code, and select Run.

WordPress is loaded for you, and the opening <?php tag is optional. For example, this snippet lists the titles of the site’s posts:

foreach ( get_posts() as $post ) {
	echo $post->post_title . "\n";
}

You can also inspect versions and configuration:

echo 'WordPress ' . get_bloginfo( 'version' ) . "\n";
echo 'PHP ' . phpversion() . "\n";
echo 'Site URL: ' . get_site_url();

Each submission is evaluated independently. Variables from one run are not available in the next run, but changes made through WordPress APIs remain in the active Playground. For example, update_option() changes the site’s database just as it would when called by a pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party..

Use Ctrl+Enter or Command+Enter to run code from the keyboard. If the snippet is incomplete, it remains in the editor so you can finish it. Parse and runtime errors appear with concise messages, including a useful source position when available.

Manage the site with WP-CLI

Switch to WP-CLI when it’s the quickest way to inspect or change WordPress. Try a read-only command first:

wp option get blogname

The leading wp is optional, so option get blogname works too. On the first WP-CLI run, Playground downloads the WP-CLI executable if it is not already available. Later commands reuse it.

Here are a few useful commands to try. Run each line separately:

wp core version
wp plugin list
wp post list --fields=ID,post_title,post_status
wp option get siteurl

You can also create content directly:

wp post create --post_title='Created from the Playground Terminal' --post_status=publish

The result reports Success: Created post followed by its ID. Run wp post list --fields=ID,post_title,post_status again to confirm the title and publish status. To view it in WordPress, close the Terminal and enter /wp-admin/edit.php in the Dock’s address field, then open the post from the Posts screen. Refreshing the welcome page alone will not display the new post. Each time you rerun the create command, it creates another post.

Set up real test scenarios

WP-CLI is especially useful for preparing a test site before you check the result in WordPress. You are building a plugin or want to check how a theme will behave in a specific screen. These examples run in a fresh Playground and use a terminal command to prep the test.

Test a WooCommerce cart and coupon

Start Playground with WooCommerce active. The plugin adds its own wp wc commands, and --user=admin gives them the permissions needed to manage store data. Create a published test product and a 10% coupon running those two commands separately:

wp wc product create --name="Playground Test Mug" --type=simple --status=publish --regular_price=19.99 --sku=playground-test-mug-01 --user=admin

wp wc shop_coupon create --code=PLAYGROUND10 --discount_type=percent --amount=10 --user=admin

Open the shop on the WordPress site, add Playground Test Mug to the cart, then apply PLAYGROUND10 under Add coupons. In a fresh Playground test, the product appeared at $19.99, and the coupon reduced the cart total to $17.99.

The commands create the fixtures; adding to cart and applying the coupon still happen in the browser. See the WooCommerce command reference for other store operations.

Prepare posts for CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. or Themes testing

When a feature needs more than one sample post, generate twelve published posts in one command:

wp post generate --count=12 --post_type=post --post_status=publish

The generated posts appear in Posts. In the Playground test, they also fill the blog’s first page and expose a second page of posts, giving testers content for pagination, sorting, search, or bulk-action checks. See the WP-CLI post generation reference.

For a focused 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 smoke test, create a post with saved Paragraph block markup:

wp post create --post_title='Block smoke test' --post_status=publish --post_content='Block smoke test'

Use the post ID reported by the command to open /wp-admin/post.php?post=ID&action=edit, replacing ID with that number. The test post opened as a Paragraph block in the editor. For a plugin block, replace this example with that block’s actual saved markup: markup that does not match the block’s definition can trigger a validation warning. The block markup guide explains the format.

A command runner, not a full shell

The integrated Terminal focuses on PHP and WP-CLI. It is not a general-purpose shell, and it does not provide an interactive TTY.

Pass every required value as part of a WP-CLI command. Commands that wait for interactive input are rejected instead of interpreting unavailable input as an empty value. Long-running interactive commands such as wp shell and wp server are not supported.

This constraint makes browser-based execution more predictable. It also protects a command from unexpectedly changing WordPress after a failed attempt to read from standard input. The same fail-fast behavior now applies to the Blueprint wp-cli step, so Blueprint commands must also provide their required arguments explicitly.

A faster path from question to answer

The Terminal fills the space between clicking through wp-admin and building a local development environment. Plugin developers can check an option or active plugin list while reproducing a bug. Documentation authors and learners can run WordPress PHP examples in context. Contributors can inspect a test site before exporting it or sharing a reproducible Blueprint.

The Terminal arrived in pull request #3808, Add Terminal to the Dock, building on an earlier request to integrate WP-CLI into the Playground website. The Dev Tools Dock update made that growing set of tools easier to show or hide.

Thanks to Alex Kirk for developing the Terminal and to the contributors who built and refined the Dock controls.

Try it and share feedback

Open WordPress Playground, check the new features, and tell us what you think. If you find a bug or have an idea for the workflow, open an issue in the WordPress Playground repository or join the #playground channel in Making WordPress Slack.

WordPress Playground is not a single interface. A developer may use the Playground CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. for local work, a Blueprint to describe a reproducible site, or playground.wordpress.net to create and share a browser-based demo. An AI agent needs to know which surface owns each part of a request.

PR #56 in the WordPress agent-skills repository updates the wp-playground skill around that idea. Instead of keeping CLI commands, Blueprint advice, browser links, and debugging notes in one long procedure, the skill becomes a small routing layer with focused references.

The result gives agents a clearer model of the whole Playground ecosystem. In this post, we are going to cover the main updates on the WordPress Playground agent skill, which is present in the WordPress repository. If you want an introduction post, I do recommend reading the previous post about the Playground agent skill.

What changes for Playground users

• A developer starting a pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. locally gets the current start workflow and a check that the plugin is active.
• A reviewer receiving a demo link gets correct encoding, public hosting and CORS requirements, and a fresh-browser verification step.
• A mixed request can move from Blueprint authoring to local execution and browser sharing without one skill pretending to own every concern.

The headline benefit is consistency across surfaces: the answer changes with the workflow, while the underlying model of Playground stays coherent.

Why the previous skill reached its limit

The previous 101-line SKILL.md put local execution, Blueprint guidance, browser sharing, and debugging in one procedure. That created three failure modes:

• Browser support was too shallow to explain the Query API, persistence, or the difference between window.playgroundSites and the active window.playground client.
• Blueprint guidance existed in both wp-playground and the dedicated blueprint skill, creating two sources of truth.
• The common plugin and theme workflow still led with server --auto-mount after the Playground CLI documentation had moved the typical development loopLoop The Loop is PHP code used by WordPress to display posts. Using The Loop, WordPress processes each post to be displayed on the current page, and formats it according to how it matches specified criteria within The Loop tags. Any HTML or PHP code in the Loop will be processed on each post. https://codex.wordpress.org/The_Loop to start.

The current high-level workflow is:

cd <plugin-or-theme-root>
node -v
npx @wp-playground/cli@latest start

The server command remains useful when an agent needs explicit mounts, a disposable environment, CI behavior, or fine-grained runtime control. The important change is teaching the agent to choose, not treating one command as the answer to every local workflow.

Route by intent, then load the detail

The new wp-playground wrapper starts by classifying the request:

Mixed requests can use more than one route. For example, “write a Blueprint, run it locally, and give me a reviewer link” uses blueprint for the JSON, the CLI reference for local execution, and the website reference for sharing.

This is progressive disclosure in practice. The entry file drops from 101 to 52 lines. The complete bundle grows because it documents more capability, but an agent loads that depth only when the request needs it.

Browser sharing becomes a first-class route

The website reference distinguishes three control surfaces:

1. URL setup through Query API parameters, Blueprint fragments, and blueprint-url.
2. Browser site management through the Sites API at window.playgroundSites.
3. Runtime interaction through the JavaScript API client exposed as window.playground.

That distinction prevents several common mistakes. playgroundSites manages site records, persistence, and the active site. The Playground client reads and writes the WordPress virtual filesystem, runs 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, makes requests, and navigates the visible site. URL parameters configure a site before it boots.

The reference also documents boundaries that matter when an agent generates a share link:

• Small inline Blueprints should be encoded once with encodeURIComponent(JSON.stringify(blueprint)).
• Larger JSON files and ZIP bundles should use ?blueprint-url=<public-url>.
• Hosted files must be public and allow cross-origin loading.
• A browser Playground cannot read an arbitrary local filesystem path.
• The final URL should be checked in a fresh browser session.

These details turn “make a Playground link” from a plausible-looking string into a repeatable handoff. The official troubleshooting guide confirms that raw JSON in a fragment, double encoding, private URLs, and missing CORS headers are frequent failure modes.

At the same time, the blueprint skill now explicitly owns Blueprint JSON and bundles, and the debugging reference replaces stale worker advice with current flags. The router can therefore choose a source before the agent starts composing an answer.

What the benchmark showed

To measure the impact, I compared three configurations:

• The new version.
• The previous skill.
• A control that answered from general model knowledge without consulting a skill.

The benchmark used the four scenarios added by the PR: CLI auto-mounting, website sharing, a mixed Blueprint/CLI/browser request, and current Blueprint schema authoring. Every configuration received the same prompts running on GPT 5.5 Sol. The two skill configurations could read only the files from their pinned revision, while the control could not read skill files or references.

On this four-scenario, 24-assertion regression suite:

Six criteria inspect the execution trace rather than the final answer. Five explicitly require the agent to use or route through a skill, so they necessarily penalize the no-skill control. Removing all six produces a cleaner comparison of answer content:

The final PR revision passed 24/24 checks: 100% on this four-scenario, 24-assertion regression suite. Only two content checks separated it from the previous skill:

• It chose npx @wp-playground/cli@latest start for the common plugin-development workflow.
• It required public, CORS-enabled hosting with Access-Control-Allow-Origin: * for Blueprint files, bundles, and referenced assets.

The Blueprint-only scenario did not distinguish answer quality; all three configurations passed its six content checks. That is evidence of preserved behavior, not improvement.

This is a focused regression suite, not a general model leaderboard. It uses one run per prompt, does not measure run-to-run variance, and grades guidance rather than live Playground execution.

Review improved the architecture

The pull request’s review history also shaped the final structure. Review feedback asked for an explicit routing procedure, top-level failure modes, stronger delegation to blueprint, and direct one-hop links from the wrapper to each reference.

The final revision removes reference-to-reference handoffs. A CLI or website reference now sends the agent back to the wrapper when the request changes direction. That keeps every focused file one hop from SKILL.md and makes the routing model easier to inspect.

Consistency across surfaces

The improvement is not merely a higher benchmark score. It is a more consistent developer experience across the CLI, Blueprints, and browser sharing. A request can move from a valid Blueprint to a local run and then to a reviewer link while each skill remains responsible for one concern.

PR #56 was merged on July 25, 2026. You can inspect the complete change set and use the four scenarios as starting points for testing real Playground tasks.