Fellyph Cintra 5:03 pm on April 7, 2026  

Migrating WordPress Playground Documentation to WordPress.org

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

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

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

The Challenge: Docusaurus vs. Handbook Formatting

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

We are taking two approaches to handle the markdown conversion:

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

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

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

  • Anchor Links & IDs (Done): We have removed all hardcoded IDs used for internal page linking, as the Handbook handles this natively.
  • Asset Loading (Done): Docusaurus uses dynamic pointing for asset folders (like images). We have updated our approach to point directly to the raw files hosted on GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged by the repository owner. https://github.com/, ensuring images render correctly without issue.
  • MDX Fragments (In Review): Playground docs heavily utilize MDX fragments (reusable snippets of code/text used across multiple pages). We have created a PR to adapt these fragments for an inline structure, and it is currently under review.
  • Callout Components (To Do): Docusaurus components for Warnings, Info, and Tips currently do not render in the Handbook. We need to create alternatives for these to ensure important points of attention are still highlighted for the user.
  • SEO & Open Graph Data (To Do): We need to double-check our Open Graph data (logos, descriptions, titles). Currently, every page has a headerHeader The header of your site is typically the first thing people will experience. The masthead or header art located across the top of your page is part of the look and feel of your website. It can influence a visitor’s opinion about your content and you/ your organization’s brand. It may also look different on different screen sizes. defining its title and summary. We need to collaborate with the Handbook team to ensure these are being parsed dynamically for optimal SEO.

The Migration Roadmap

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

Phase 1: The English Migration

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

Phase 2: Internationalization (i18n)

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

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

  • We will define a set of pages eligible for translation and publishing in the new handbook, something similar to what we have in the current docs. At a minimum, the first “blockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience.” of introductory pages must be translated; otherwise, the user will be redirected to the English version, the current behavior with Docusaurus.
  • Fallback Plan: Until Phase 2 is complete, we will keep the Docusaurus site live strictly as a fallback for international users. English traffic will be redirected to WordPress.org, while translated content will remain on Docusaurus until it can be safely migrated.

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

Phase 3: The “Ask AI” Feature

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

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

Next Steps

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

Fellyph Cintra 7:24 pm on January 15, 2026  

Playground meeting summary: January 9, 2026

This post summarizes the first Playground team meeting of 2026, held on January 9, 2026, in the  #playground SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ channel.

Announcements

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. Updates
Three UI improvements shipped in December based on community feedback:

  • Unsaved Playground warning – alerts users before losing work
  • Launch WordPress Playground panel – new dedicated panel for launching instances
  • Quick links – fast access to frequently visited pages

Read the full post (also available in Portuguese).

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-WASM Package Split
WordPress Playground now offers individual php-wasm packages for each PHP version (7.2–8.5). This modular approach allows developers to load only the PHP version they need, reducing bandwidth. Existing code remains compatible. Learn more.

Blueprints Library Preview
The internal blueprints library now includes visual previews, allowing users to see blueprint results directly from Playground before launching.

Dynamic CJS Imports
Dynamic imports for published CommonJS modules are now available.

Standalone 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. Demo Page
A new standalone demo page (playground-block-demo.html) brings the Playground Block 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.’s functionality to playground.wordpress.net. Features include:

  • Multi-file project editing (PHP, JS, JSX via esbuild-wasm)
  • Real-time WordPress previews
  • URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org parameter configuration for full-page and embedded views

Documentation
New translations added: Bengali (@noruzzaman), Portuguese (@André Ribeiro), and Japanese (@shimomura tomoki).

Community
Contributor badges awarded to @SirLouen, @Mehraz Morshed, and @Sohilbhai Ghanchivahora.

Contributor Updates

@fellyph shared progress on:

  • A PHP learning tool using php-wasm
  • Documentation updates for non-developers, including two new guides: “WordPress Playground for non-developers” and “Testing themes and plugins”
  • Video guides for runCLI and GitGit Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. Git is easy to learn and has a tiny footprint with lightning fast performance. Most modern plugin and theme development is being done with this version control system. https://git-scm.com/ Actions (PRs under review)
  • UI screenshot updates and front-end cleanups

Open Floor

The team asked: What would you like to see in Playground in 2026?

Fellyph Cintra 12:10 pm on February 6, 2026  

wp-env now runs WordPress with Playground runtime

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

One command. Zero Docker. Full WordPress:

npx @wordpress/env start --runtime=playground

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

Why does this matter?

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

What makes the Playground runtime appealing:

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

What works in both runtimes?

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

FeatureDockerPlayground
PluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party./theme mounting✅✅
Custom PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php versions✅✅
Xdebug support✅✅
MultisiteMultisite Multisite is a WordPress feature which allows users to create a network of sites on a single WordPress installation. Available since WordPress version 3.0, Multisite is a continuation of WPMU or WordPress Multiuser project. WordPress MultiUser project was discontinued and its features were included into WordPress core. Advanced Administration Handbook -> Create A Network.✅✅ (experimental)
MySQLMySQL MySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com database✅❌ (SQLite)
phpMyAdmin✅❌ (planned)
SPX profiling✅❌
Separate tests environment✅❌
wp-env run command✅❌

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

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

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

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

What about my existing configuration?

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

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

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

When should you still use Docker?

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

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

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

Resources:

Share your feedback

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

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

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

Fellyph Cintra 7:34 pm on November 26, 2025  

Preview Gutenberg Development Branches in Your Browser

WordPress Playground now loads 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/ development branches directly in your browser. Test the latest trunk changes or explore feature branches without creating a pull request or setting up a local environment.

This solves a common challenge: testing bleeding-edge Gutenberg development typically requires cloning repositories, running build scripts, and managing local installations. Now you can skip all that.

Why does this matter?

New features land trunk daily, and experimental work occurs in feature branches before being merged into pull requests. Previously, you could only preview specific PRs in Playground, and now you can preview any branch related to a pull request.

This opens new possibilities:

  • Test the Gutenberg trunk branch to catch issues before they reach release.
  • Explore Gutenberg experimental features and fixes before they’re merged.

How do you preview branches?

Playground introduces two new Query API parameters gutenberg-branch. Add them to your Playground URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org to load specific branches.

Preview Gutenberg trunk or a specific feature branch:

https://playground.wordpress.net/?gutenberg-branch=trunk

Other branches:

https://playground.wordpress.net/?gutenberg-branch=add/new-feature

What about pull requests?

Pull request previewing still works exactly as before for Gutenberg and WordPress coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress.. If you know the PR number, use:

https://playground.wordpress.net/?core-pr=9500
https://playground.wordpress.net/?gutenberg-pr=73010

What should you know?

When you preview a branch, Playground loads the latest available build artifact from 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/ Actions. If GitHub Actions is still building the most recent commit, Playground uses the next available build. This means you might see changes from a few commits back, not the absolute latest code. This approach strikes a balance between freshness and reliability.

This feature works anywhere you use the Playground Query 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., ideally, for testing and bug reporting. The playground can be embedded for educational purposes in future releases. For example, if you’re documenting a new Gutenberg feature still in trunk, link directly to a Playground instance that demonstrates it.

Start testing today

The WordPress and Gutenberg teams constantly ship improvements. With branch previewing, you can explore these changes the moment they merge, report issues early, and contribute to WordPress development—all from your browser.

Try it now and learn more about Query API documentation.

Adam Zieliński 9:44 pm on December 3, 2025  

WordPress Playground: 2025 Year in Review

A lot happened for Playground this year! Let’s review what changed and why it matters for your work:

99+% of WordPress Plugins Supported in Playground

Nearly every pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. from the WordPress plugin directory works in Playground. In testing with the top 1,000 plugins, 99% install and activate successfully. The handful that don’t work yet either crash even outside of Playground or need a few more Playground platform improvements the team is actively working on.

Speaking about compatibility, Playground is now powerful enough to run 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 applications beyond WordPress:

  • PHPMyAdmin for database management – available via the 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. on playground.wordpress.net
  • Composer for managing PHP dependencies – available for developers via Blueprints
  • Laravel – try it out! 

…and a lot more! Try bringing your favorite PHP tools into Playground – they may just work. And please share your experience with others in the comments or at the #playground SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ channel!

Playground Got Faster—A Lot Faster

Playground performance got a major boost in 2025. Enabling OpCache alone cut the average response time by 42%—from 185ms down to 108ms. On top of that, the Playground CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. uses multiple workers (with the --experimental-multi-worker flag) and processes concurrent requests in parallel instead of making them wait in line.

There’s a lot more! Playground now pre-fetches update checks before you even open wp-admin. Network responses start streaming right away instead of waiting for complete downloads. WordPress loads before the optional parts of the Playground app. More Playground assets are cached, and the cache is utilized more.

All these improvements compound. Playground feels faster because it is faster.

New PHP Extensions Support Modern Development Workflows

In 2024, Playground established a solid foundation with coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. PHP extensions such as bcmath, xml, curl, and mbstring. In 2025, the support extended to:

  • XDebug – available in CLI with IDE integration.
  • SOAP, OPCache, ImageMagick, GD 2.3.3, Intl, and Exif PHP extensions.
  • WebP and AVIF image formats.
  • Networking is now enabled by default on playground.wordpress.net, allowing PHP to request any URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org.
  • There’s also an ongoing exploration to use XDebug through browser devtools and without an IDE.

In addition, Playground now supports dynamic extensions under the hood, with Xdebug and Intl being the first two dynamic extensions. This unlocks a future on/off switch for loading specific extensions so that you can test how your plugin behaves in different hosting environments.

State of the Art 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 Emulation

In 2025, Playground upgraded its MySQL support with a brand-new, state of the art MySQL-on-SQLite database driver. It’s likely the most comprehensive open-source library of its kind in any language. Developed in the sqlite-database-integration plugin, it leverages a custom-made MySQL query parser and translation logic to support even those highly nuanced MySQL queries.

In 2025, it became powerful enough to support:

  • PHPMyAdmin and Adminer – available with a click directly on playground.wordpress.net.
  • 99+% of WordPress directory plugins.
  • 99+% of WordPress core unit tests.

Looking forward, the Playground team is working on MySQL binary protocol support. Once that lands, you’ll be able to use the mysql CLI, connect with database management apps, establish PDO connections, and tap into the full ecosystem of MySQL developer tools—all running against Playground’s CLI SQLite backend.

A Developer Toolbox, One Click Away

playground.wordpress.net now provides plenty of developer tools right in your browser:

And if you’d like to preview Pull Requests in your project using Playground, see the “Try in Playground” GitHub action. It automatically adds a preview link to every pull request in your repository. Reviewers just click the link and see your changes running in WordPress—no need to pull code or configure anything locally.

Local CLI Workflows

Playground CLI hit a stable release with several powerful new features to streamline your development workflow:

  • Auto mode to start a local WordPress server with your plugin or theme installed. Run npx @wp-playground/cli server –auto-mount in your local plugin or theme directory. That’s it!
  • Debug with XDebug. Add a single CLI flag and immediately connect via VS Code or PhpStorm. Set breakpoints, watch variables change as code executes, and step through your functions line by line. The Playground team is also exploring connecting XDebug to Chrome DevTools (unreleased, work in progress).
  • Multi-worker support: Use –experimental-multi-worker to enable concurrent operations. While one worker waits for a network response, another processes PHP. No more slowdowns.
  • runCLI() lets developers embed WordPress Playground instances directly 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/Node.js applications. It’s useful for automated testing workflows and building desktop apps, such as Studio, on top of Playground.

Blueprints

Blueprints (WordPress starter configurations) received many major upgrades this year:

  • Blueprints editor – Create your Blueprints directly on playground.wordpress.net with the new, built-in editor.
  • Blueprint bundles – Ship images, zip files, and media with your Blueprint.
  • Visual Blueprints browser – Explore ready-made starter sites for blogs, news sites, and organizations from the Blueprints gallery. Launch them in Playground with a click.
  • .git directory support – Create a .git directory for any repositories cloned via Blueprints to use with your everyday git tools.
  • Blueprints v2 living specification was published to make Blueprints more accessible to humans and AI tools. The new format standardizes how post types, content, translations, fonts, and media files are defined, while making the notation more succinct. An all-PHP Blueprints runner is being developed in the php-toolkit repository, and Playground CLI runs it when the --experimental-blueprints-v2-runner flag is used.

Other highlights

Community Impact

Playground was used 1.4 million times this year to showcase plugins, test code changes, and teach others.

The community stepped up in ways that went far beyond code. Community contributors translated the documentation into French, Spanish, Portuguese, Japanese, Gujarati, and Tagalog, with Bengali translations now underway. Over 1,000 plugins from the directory enabled the Playground-powered “Preview” button. 48 developers earned the Playground contribution badge for their work on code, documentation, and community support.

From the flagship events down, Playground was everywhere: at WordCampWordCamp WordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Europe 2025 @berislavgrgicak showed how to build automated tests with Playground, and @bph walked through creating one-click demos at WordCamp Asia 2025. @danieldudzic demoed testing WooCommerce faster than a Formula 1 pit stop at WordCamp Gdynia. @nilovelez called Playground “the best tool ever invented for teaching WordPress” at WordCamp Galicia. @muryam brought Playground to WordCamp Islamabad, showcasing how to build, test, and explore WordPress. And even beyond that, @mrfoxtalbot, @wpaurorautasic, @fellyph, @sakaruk, and @magdalenapaciorek took Playground to Madrid, Lisboa, Wrocław, Nepal, and Rio de Janeiro, turning Playground into a recurring theme in talks on testing, education, and release workflows.

Playground also enabled the community to build great tools and workflows. @smrubenstein integrated Playground CLI with GitHub Copilot and shipped four features in one week—work that would otherwise take months. @bacoords built dynamic Blueprints running on Cloudflare Workers for runtime-configurable WooCommerce demos. Studio, a local development environment, added support for Blueprints. Telex lets you generate Gutenberg blocks from text prompts and instantly test them in Playground.

There’s more! @akirk added many new steps to his Blueprint development tool Playground Step Library, a versatile paste handler for Markdown, 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., 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., and more. @jamesmarsland launched PootlePlayground.com, an AI-aided Blueprint generator. And TYPO3—a different CMS—built a TYPO3 playground with WordPress Playground as a foundation, proving the impact reaches beyond the WordPress ecosystem.

Kudos to all contributors:

@ajitbohra, @akirk, @aksyonov, @andraganescu, @amieiro, @ashfame, @aslamdoctor, @bacoords, @berislavgrgicak, @beryldlg, @bph, @brandonpayton, @dd32, @devmuhib, @dhruval04, @dhruvang21, @dilip2615, @fellyph, @getdave, @hmbashar, @huzaifaalmesbah, @ingeniumed, @ivanottinger, @janjakes, @janwoostendorp, @jdahir0789, @jeffpaul, @jhimross, @jonsurrell, @josevarghese, jswhisperer, @juanmaguitar, @justinnealey, @karthickmurugan, lukaszuznanski, madhavraj2004, @marc4, mbuella, @mehrazmorshed, @merkushin, @mosescursor, @mrfoxtalbot, @mujuonly, @mukesh27, @muryam, @n8finch, @ndiego, @nikunj8866, @noruzzaman, oskardydo, @passoniate, @praful2111, @psykro, @ravigadhiyawp, @rollybueno, @sakaruk, @sandeepdahiya, @sandipsinh007, @sejas, @shailu25, @shimotomoki, @shiponkarmakar, @sirlouen, @tomayac, @vipulgupta003, @wojtekn, @wpaurorautasic, @yannickdecat, @zaerl, @zieladam.

Thank you all for being part of this journey! Here’s to making WordPress easier and more accessible for everyone.

Props to @akirk, @berislavgrgicak, @janjakes, @bpayton, @yannickdecat for their help with writing and reviewing this post. Also, props to all of you who helped get Playground where it is today!

+make.wordpress.org/core/

Fellyph Cintra 6:01 pm on November 24, 2025  

Debugging with Xdebug is now available in WordPress Playground

Have you ever faced a moment where your application won’t run, and you need to understand the steps that led to the failure? Xdebug is the perfect tool for this, but debugging a 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 application inside WebAssembly was a challenge until one of the most recent updates to WordPress Playground.

WordPress Playground now supports Xdebug. You can connect Visual Studio Code and PhpStorm IDEs to debug PHP code with breakpoints, step-by-step execution, and variable inspection. This experimental feature needs your feedback.

What can you do with Xdebug?

Connect Xdebug in Playground to your IDE to:

  • Set breakpoints — Pause execution on specific lines
  • Step through code — Move line by line during execution
  • Inspect variables — View values during execution
  • Evaluate expressions — Test code in the current context

Getting Started with Xdebug

Let’s debug a simple 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. using the Playground CLI and Xdebug to demonstrate this feature. But don’t worry, this feature is also available for the PHP-WASM CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress..

Prerequisites

You need:

  • Node.js 23 or higher and npm installed
  • @wp-playground/cli version 3.0.20 or higher
  • Visual Studio Code with the PHP Debug extension installed or the Xdebug extension configured in PhpStorm.

For Visual Studio Code and IDEs forked from it, we do recommend the official PHP Debug extension from Xdebug.org. This is required for debugging PHP in VS Code, not a specific requirement for WordPress Playground.

Configuration Steps

1. Prepare your code for testing

For this demo, I will use the following code. It displays a message in the WordPress Admin Dashboard. To see this code in action, you must access the /wp-admin/ address:

<?php
/**
 * Plugin Name: Simple Admin Message
 * Description: Displays a simple message in the WordPress admin
 * Version: 1.0
 * Author: Playground Team
 */


// Prevents direct access
if (!defined('ABSPATH')) {
    exit;
}


// Displays admin notice
function sam_display_admin_message() {
    $message = 'Hello! This is a simple admin message.';
    ?>
    <div class="notice notice-info is-dismissible">
        <p><?php _e($message, 'simple-admin-message'); ?></p>
    </div>
    <?php
}
add_action('admin_notices', 'sam_display_admin_message');

2. Configure your IDE to listen for Xdebug

The WordPress Playground CLI has a flag that can help developers if they don’t have Xdebug configured: --experimental-unsafe-ide-integration=, which currently supports two IDEs: vscode and phpstorm.

This will save time by generating the necessary files to get your debugging started.

Visual Studio Code

To start debugging, VS Code needs the .vscode/launch.json file. Here is an example:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Listen for Xdebug",
      "type": "php",
      "request": "launch",
      "port": 9003
    }
  ]
}

Start the debugger with F5 or “Run > Start Debugging”. Run the plugin with the Playground CLI to see the execution stop when the code hits a breakpoint.

To debug the plugin above, we can initialize the plugin in the Playground CLI with the following code:

npx @wp-playground/cli@latest server --xdebug --experimental-unsafe-ide-integration=vscode --auto-mount

PhpStorm

Configure PhpStorm with path mappings and a PHP Remote Debug configuration.

  1. Create a PHP Remote Debug configuration.
  2. Click on Start Listening for PHP Debug Connections.
  3. Run the plugin with the Playground CLI.

To run the plugin with the Playground CLI, execute the command in the terminal:

npx @wp-playground/cli@latest server --xdebug --experimental-unsafe-ide-integration=phpstorm --auto-mount

See the Xdebug documentation in PhpStorm for detailed configuration instructions.

Running Xdebug with PHP-WASM CLI

Another option is to use Xdebug with PHP-WASM CLI, which is useful when you would like to debug only PHP without a WordPress environment.

To run it, you will need to set up Xdebug in your development environment. Once you are ready, add the breakpoints to your PHP file and run the command point to the file that you would like to debug. For example, the file below is located at src/test.php:

<?php

$test = 42; // Set a breakpoint on this line

echo "Output!n";

function test( $output ) {
    echo "Hello Xdebug World!n" . $output . "n";
}

test($test);

At the terminal, you run the command:

 npx @php-wasm/cli@latest --xdebug php/test.php

The result will be starting the debugging mode at the IDE:

A WordPress Playground team effort to solve a complex problem

Bringing Xdebug to WebAssembly required solving technical challenges. The Playground team spent months turning a tracking issue from May 2023 into working code.

Technical Achievement

The WordPress Playground team has made significant strides in integrating Xdebug for in-browser debugging. This effort involved numerous pull requests that tackled a range of technical challenges:

  • Asyncify Extension: Added Xdebug support via asyncify-specific shared extension builds and loaders.
  • IDE Integration Enhancements: Introduced experimental IDE path mappings for seamless debugging between the Playground’s virtual file system (VFS) and host IDEs.
  • Xdebug Bridge: Enabled the bridge to read files directly from the VFS, aligning breakpoints and source files for consistent debugging experiences.
  • CLI UX Improvements: Refined the CLI experience to prevent breakpoints from interrupting the Playground boot process unnecessarily.
  • DevTools & Debugger Enhancements: Preloaded files for improved DevTools debugging (#2527), added syntax highlighting (#2566), and enhanced array inspections and Xdebug protocol handling (#2409).
  • Upgraded Toolchain (#2910): Upgraded Emscripten to address linker issues, ensuring smooth dynamic loading of shared extensions like Xdebug.

Together, these enhancements have enabled robust step-debugging workflows, bridging the Playground’s WASM environment with modern IDE capabilities. Additionally, earlier groundwork (#673, #831) on dynamic loading set the foundation for these advancements.

The result? Xdebug in WordPress Playground isn’t just functional; it further empowers development and testing entirely in-browser.

What’s Next

The team continues working to bring Xdebug support to more Playground builds and explore debugging directly within browser developer tools.

Try Xdebug today and share your feedback on the original tracking issue. Check the Xdebug documentation for more configuration instructions, IDE integration guides, and troubleshooting tips.

Props to @zieladam and @yannickdecat

Fellyph Cintra 9:23 am on October 13, 2025  

WordPress Playground Meeting Summary: October 10, 2025

Location: #playground Slack Channel

The WordPress Playground team held its weekly meeting on October 10, 2024. Here’s a summary of what was discussed.

Announcements

AI-Powered Documentation Search

The team added a new feature to the WordPress Playground documentation that uses AI to answer user questions. The implementation uses kapa.ai and is currently in testing. The team is collecting community feedback. Thanks to @zaerl for implementing this feature.

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

A new PHP Playground beta was released, featuring an IDE-like interface with:

  • File Explorer.
  • Terminal with support for PHP, WP, and Composer commands.
  • Browser-based development capabilities.

This enhancement builds on the previous version created by @zieladam and incorporates community feedback. The new version enables users to use Composer and compile PHP directly from the browser.

Playground Importer Improvements

Thanks to issue reports from @bph, the Playground importer now auto-rewrites URLs from the original site to Playground paths using wordpress-importer 0.9.1+.

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

The Playground CLI received performance improvements, now using multi-worker startup by sharing WordPress files via the local filesystem instead of zip copying.

Landing Page Improvements

@zieladam refactored the landing page, improving performance and fixing issues some users experienced due to customizations on the web version of Playground. The team also added a new favicon that is visible in both light and dark modes, addressing feedback from @Krupa.

Merge Activity

Since the last meeting, the team has merged 30 pull requests.

Documentation Updates

The team celebrated translation contributions from @Dilip Modhavadiya, @Béryl, @shimomura Tomoki, and @Shail Mehta, who submitted new translations for French, Japanese, Gujarati, and Tagalog.

@fellyph created a base for Bengali translations and is working with @Muhibul Haque to expand Bengali language support.

Community Highlights

Contributor Badges

Two more community members earned the contributor badge this week, bringing the total to 37 members with contributor badges.

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

Several community members presented about WordPress Playground at recent WordCamps:

The team encourages anyone who has given a talk about Playground or created related content to share it so the Resources page can be updated.

Updates from Contributors

@fellyph attended WordCamp Galicia, where he collected community feedback, ran the Playground table at contributor dayContributor Day Contributor Days are standalone days, frequently held before or after WordCamps but they can also happen at any time. They are events where people get together to work on various areas of https://make.wordpress.org/ There are many teams that people can participate in, each with a different focus. https://2017.us.wordcamp.org/contributor-day/ https://make.wordpress.org/support/handbook/getting-started/getting-started-at-a-contributor-day/, reviewed translations in the repository, and prepared the base structure for Bengali translations. He plans to prepare a page for WP Credits in the documentation and update the Playground documentation.

@bpayton worked on updates to make it easier for teams to build and self-host the Playground web app, giving teams control over their deployedDeploy Launching code from a local development environment to the production web server, so that it's available to visitors. version while still being able to use playground.wordpress.net.

@zieladam has been:

  • Testing the new XDebug feature.
  • Exploring full-fledged 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. development in the browser by running Node.js and webpack, which could complement the recently shipped PHP Playground beta.
  • Helping Birgit import navigation menus via WXR and troubleshooting a bug in the process.

@janjakes has been improving the SQLite 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., intending to support PHPMyAdmin in the near future.

Open Floor

Translating the Admin Panel 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.

@fellyph raised a question about whether the admin panel UI at playground.wordpress.net should be translated. After watching @nilovelez‘s talk about WordPress Playground, he noted it would be helpful if the UI could be explained in the presenter’s native language.

Community feedback:

  • @Moses Cursor noted that people from non-English speaking regions would be encouraged to use Playground more if the interface were available in their language.
  • @bph emphasized that translating the interface would help non-English speakers embrace Playground and broaden its reach into non-developer spaces, such as teaching writing. Without translation, non-English speakers have difficulty using Playground for various purposes.

@fellyph will create an issue to track this feature request.

Next Steps

For more information, join our #playground Slack Channel, and see you in our next chat, which is scheduled for October 24th.

Jan Jakeš 3:32 pm on June 13, 2025  

Introducing a new SQLite driver for WordPress

The new SQLite driver is now available in the SQLite Database Integration plugin (currently behind a feature flag), and powering the WordPress Playground website today.

Following the refactoring, the new SQLite driver now matches the current driver in terms of features and surpasses it in several key areas. However, there are still some aspects that would benefit from further feedback. Thanks to its new architecture, integrating additional features is now much faster, and work is underway to enhance 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 compatibility even further.

Architecture highlights

The new SQLite driver translates MySQL queries into SQLite statements and emulates MySQL behavior using a robust new approach, which includes:

  1. A complete, fast MySQL SQL lexer written in pure 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 with zero dependencies.
  2. A complete, version-aware MySQL SQL grammar definition, adapted from the MySQL Workbench grammar.
  3. Basic tooling to process and compress the grammar in pure PHP.
  4. An extra lightweight, universal grammar parser written in pure PHP with zero dependencies, by @zieladam
  5. An extensive test suite of 70 000 MySQL queries that we can parse successfully.
  6. A new SQLite driver that translates and emulates MySQL queries on top of SQLite, using the abstract syntax tree produced by the new parser.
  7. A comprehensive MySQL information schema emulation layer on top of SQLite.
  8. An automated migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. flow for databases created with the previous SQLite driver.
  9. New test suites, including the WordPress CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. PHPUnit test suite, with over 99% of tests already passing.

Trying the driver

⭐️ Please share your feedback and real-world test results via 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/ issues or as comments on this post.

Running WordPress on SQLite

WordPress and its plugins have long depended on MySQL, making a seamless switch difficult without breaking compatibility. Past SQLite integrations have mostly translated MySQL SQL into SQLite-compatible queries, but fully supporting advanced features and MySQL-specific behaviors remained challenging.

The new driver still processes MySQL queries by emulating them on SQLite, sometimes through direct conversion and other times with complex transformations. What’s new is a deeper emulation: queries are now parsed into an abstract syntax tree (AST), and key MySQL information schema tables are replicated in SQLite. This approach enables more robust support for MySQL features, greatly improving WordPress compatibility with SQLite.

New features

While the initial goal of the new SQLite driver was to reach full feature parity with the current implementation, it also introduces numerous enhancements and advanced capabilities:

  • Advanced support of the MySQL syntax.
    • sub-queries.
    • UNION and UNION ALL operators.
    • SHOW and DESCRIBE statements.
    • INFORMATION_SCHEMA tables.
    •  TEMPORARY tables.
    • table administration statements (TRUNCATE, ANALYZE, CHECK OPTIMIZE, REPAIR).
  • Support for 
    • STRICT_TRANS_TABLES and STRICT_ALL_TABLES SQL modes.
    • NO_BACKSLASH_ESCAPES SQL mode.
    • USE <database> statement for the main database and INFORMATION_SCHEMA.
  • Automatic migration of databases created with the current SQLite driver.

Thanks to its redesigned architecture, the new driver lays the groundwork for future support of additional MySQL features, some of which were nearly impossible to implement in the current driver.

Examples

Take a brief look at some of the new tricks that the new driver can already handle.

Create the wp_users table:

CREATE TABLE wp_users (
  ID bigint(20) unsigned NOT NULL auto_increment,
  user_login varchar(60) NOT NULL default '',
  user_pass varchar(255) NOT NULL default '',
  user_nicename varchar(50) NOT NULL default '',
  user_email varchar(100) NOT NULL default '',
  user_url varchar(100) NOT NULL default '',
  user_registered datetime NOT NULL default '0000-00-00 00:00:00',
  user_activation_key varchar(255) NOT NULL default '',
  user_status int(11) NOT NULL default '0',
  display_name varchar(250) NOT NULL default '',
  PRIMARY KEY  (ID),
  KEY user_login_key (user_login),
  KEY user_nicename (user_nicename),
  KEY user_email (user_email)
) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

The new driver can also execute arbitrarily complex queries using the INFORMATION_SCHEMA:

SELECT
  cols.DATA_TYPE,
  stats.INDEX_NAME,
  stats.COLUMN_NAME
FROM INFORMATION_SCHEMA.COLUMNS AS cols
JOIN INFORMATION_SCHEMA.STATISTICS AS stats
  ON  cols.TABLE_SCHEMA = stats.TABLE_SCHEMA
  AND cols.TABLE_NAME   = stats.TABLE_NAME
  AND cols.COLUMN_NAME  = stats.COLUMN_NAME
WHERE
  cols.TABLE_SCHEMA   = 'wp'
  AND cols.TABLE_NAME = 'wp_users'
ORDER BY INDEX_NAME ASC;
-- bigint   PRIMARY         ID
-- varchar  user_email      user_email
-- varchar  user_login_key  user_login
-- varchar  user_nicename   user_nicename

You can add a bit more advanced syntax like UNION, DISTINCT, CTEs, and function calls:

WITH
  cols AS (
    SELECT COLUMN_NAME AS column_name
    FROM INFORMATION_SCHEMA.COLUMNS
    WHERE TABLE_SCHEMA = 'wp' AND TABLE_NAME = 'wp_users'
  ),
  indexes AS (
    SELECT DISTINCT INDEX_NAME AS index_name
    FROM INFORMATION_SCHEMA.STATISTICS
    WHERE TABLE_SCHEMA = 'wp' AND TABLE_NAME = 'wp_users'
  )
SELECT CONCAT(column_name, ' (column)') AS name
FROM cols
UNION ALL
SELECT CONCAT(index_name, ' (index)') AS name
FROM indexes
ORDER BY name;
-- ID (column)
-- PRIMARY (index)
-- display_name (column)
-- user_activation_key (column)
-- user_email (column)
-- user_email (index)
-- user_login (column)
-- user_login_key (index)
-- user_nicename (column)
-- user_nicename (index)
-- user_pass (column)
-- user_registered (column)
-- user_status (column)
-- user_url (column)

Finally, let’s export the table schema:

SHOW CREATE TABLE wp_users;
-- CREATE TABLE `wp_users` (
--   `ID` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
--   `user_login` varchar(60) NOT NULL DEFAULT '',
--   `user_pass` varchar(255) NOT NULL DEFAULT '',
--   `user_nicename` varchar(50) NOT NULL DEFAULT '',
--   `user_email` varchar(100) NOT NULL DEFAULT '',
--   `user_url` varchar(100) NOT NULL DEFAULT '',
--   `user_registered` datetime NOT NULL DEFAULT '0000-00-00 00:00:00',
--   `user_activation_key` varchar(255) NOT NULL DEFAULT '',
--   `user_status` int(11) NOT NULL DEFAULT '0',
--   `display_name` varchar(250) NOT NULL DEFAULT '',
--   PRIMARY KEY (`ID`),
--   KEY `user_login_key` (`user_login`),
--   KEY `user_nicename` (`user_nicename`),
--   KEY `user_email` (`user_email`)
-- ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci

The definition is returned exactly as supplied, confirming faithful emulation of MySQL’s SHOW CREATE TABLE.

The above scenario was never supported by the previous driver, and implementing it would have been extremely difficult due to its basic, token-based architecture. With the new driver design, advanced use cases like this can now be supported much more naturally.

What’s next

Stabilizing the new SQLite driver in the 2.x line of the SQLite Database Integration plugin requires your feedback. Once there is enough confidence, a  3.0 of the 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. will be released where the new driver will be enabled by default (and not behind a feature flag like in 2.x). The new driver is also being continuously tested for compatibility with plugins from the WordPress Plugin Directory and expanding feature coverage.

After the 3.0 release and the new SQLite driver enabled by default, the development focus will shift to expanding MySQL functionality coverage, improving performance, and stabilizing the 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., with the future prospect of integrating the driver into WordPress Core.

Looking even further ahead, the new lexer and parser pipeline lays the foundation for supporting additional database engines within the WordPress ecosystem.

Props to for reviewing to @zieladam and @bph

Bero 10:46 am on August 5, 2024  

Introducing Offline Mode and PWA Support for WordPress Playground

We’re excited to share that WordPress Playground now supports offline mode and can be installed as a Progressive Web App (PWA). These features allow you to explore and experiment with WordPress without needing an active internet connection, making it easier to develop and test your ideas on the go.

Offline mode

When you first visit Playground.WordPress.net, your browser automatically caches all the necessary files to use Playground. From that point on, you can access Playground.WordPress.net, even while flying or in areas without internet access, ensuring you can continue working on your projects without interruptions.

PWA support

For an enhanced experience, you can also install Playground on your device as a Progressive Web App (PWA).

This allows you to launch the Playground directly from your home screen—just like a native app—and makes accessing your WordPress projects or environment quicker and more convenient. For detailed instructions on installing PWAs, refer to this MDN guide.

Current limitations

While offline, there are a few limitations to keep in mind:

  • You won’t be able to switch between the 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 WordPress versions, as this would require downloading additional files.
  • Offline mode works in most web browsers, but unfortunately, it doesn’t work in Firefox at this time.
  • When you install Playground as a PWA, it uses the current URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org to install the app. This means that every time you open the Playground app, it will start with the settings from that URL. You can adjust the settings within the app after it starts, but note that the settings will be restarted the next time you open it.

Share your feedback

Please share your feedback with us on the Making WordPress Slack or report any issues you find on GitHub.

Bero 11:04 am on December 16, 2024
Tags: ,   

Playground Team Meeting Summary – December 13, 2024

The Playground team met to discuss recent updates, ongoing projects, and community questions. (Slack script) facilitated by @berislavgrgicak

Announcements

Contributor Updates

Open Floor

Thank you to all contributors for your participation! Stay tuned for updates in SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ and on the Make WordPress blog.

#summary #meeting

Props to @zieladam for reviewing.