Jonathan Desrosiers 1:54 pm on June 15, 2026
Tags: ,   

Core Committers Meeting – WordCamp Europe 2026

On June 5, 2026, CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Committers in attendance (including emeritus) at WordCamp Europe in Kraków, Poland gathered for a brief informal meeting.

The WordPress Core Committers posing on stage at WordCamp Europe 2026 after meeting.

There was no formal agenda, but a few goals for the meeting were mentioned at the beginning:

  • Allow newer committers to meet more senior ones.
  • Allow anyone to raise questions, concerns, or suggestions that have been on their minds.
  • Just spend some time together chatting and getting to know each other.
  • Discuss short and medium term challenges.

Below are some brief notes from discussions that happened following Chatham House Rule.

Reducing Friction Between Code Bases

The meeting started by discussing the recent changes to the build scripts in both wordpress-develop and gutenberg aimed at making it easier to sync the changes from gutenberg 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/ into wordpress-develop in SVNSVN Subversion, the popular version control system (VCS) by the Apache project, used by WordPress to manage changes to its codebase..

  • It was painful at first, but the most disruptive initial issues have been addressed.
  • The svn:ignore properties are still out of sync with the changes made to .gitignore.
  • #64971 is open to address this.
  • This is very easy to miss due to differences between SVN 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/.
  • This process should be a reoccurring task.
  • The process is very manual in nature (every change needs human review and confirmation).
  • There could possibly be some form of automation to detect when they fall out of sync.
  • The new concepts behind the build script changes (pages and routes) are quite novel. This took some time to adjust and learn for most to understand and get right.
  • New edge cases are still being discovered, so everyone needs to be attentive and responsive to reports. Example: discontinuing the practice of pinning @wordpress npm dependencies to each release has made the package-update --dist-tag=7.0 no longer works (see the related conversation in Slack).
  • While working on build tooling-related tasks is not always enjoyable, more eyes are needed to refine the changes.
  • Overall, this brought the two code bases closer together and clears the way for more frequent syncing. But the speed at which each operates is still quite different.

Improving Communication

Maintainers need to put more of an emphasis on consistency and err on the side of over communicating. Announcing in progress explorations or planned changes earlier has many benefits:

  • Avoids breaking contributor workflows
  • Sets consistent and clear expectations (no surprises)
  • Limits unconsidered edge cases
  • Increases the chances for feedback
  • Higher quality feedback overall
  • Ensures the full context, motivations, background, and goals behind a given change are known and understood.
  • Smaller gap between perceptions and realities.

The form of communication was not clear and would likely vary at different phases. It could involve RFCs (requests for change), TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. updates, weekly Dev Chat discussions, and more.

A Canary-style Approach to WordPress

A proposal was made to consider approaching WordPress development in a similar way to Chrome (using a Canary-style version with feature flags). The idea is to have the ability to work on more features at once, faster, being more proactive about requesting feedback, collect more crash telemetry, etc.
There was a healthy discussion that ultimately led to agreement that this would represent a significant shift from how Core is built and maintained today. Everything from how code is committed to how Trac/GitHub/tickets are utilized to how the project communicates what’s being worked on and what changes are upcoming would need to change. Some talking points that were discussed at length without a resolution:

  • What would the difference between Core + 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/ 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. be from these Canary-style builds?
  • How would someone decide between builds?
  • How would the location be chosen for a feature (stable in wordpress-develop, experimental in gutenberg, etc.)?
  • There’s currently no concept of experimental features within wordpress-develop, but there is in Gutenberg.
  • When someone builds a feature on a Canary-style build and dependent code is removed or changed, that breaks.
  • Should there still be a Gutenberg plugin? What if PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher was not allowed in Gutenberg and had to be committed to wordpress-develop instead?

Currently, wordpress.org seems to be the canary along with anyone else running the nightly builds. WordPress.com runs the Gutenberg plugin, which has made it much easier to update once reaching the 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. release phase of a release. However, w.com is an outlier and many of the problems that are found do not typically affect more managed hosts.

More Testing More Often

It was mentioned that the problem that was being targeted is that it’s not easy to test one specific feature and the project can often receive late or inadequate levels of testing. There also can be a hesitance to merge certain features because it’s not clear what the desired level of testing is, or if that has actually been achieved.

Most of the discussion so far was acknowledged to be a technical solution to a communications problem. Canary-styled releases have also become a marketing solution for Chrome, not necessarily a “more testing” one. It could also become even more confusing for users very quickly. The conversation shifted to discussing the feedback problem.

  • Far too few sites test the beta/RCrelease candidate One of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). versions for each release.
  • It’s unknown how many sites turn on the experiments in the Gutenberg plugin. Or how many actually interact with those experiments.
  • The Beta Tester plugin currently only has ~3,000 active installs, and those installs may not be configured to use non-stable releases.

Beta Testing Natively In Core

One option mentioned was to consider merging the Beta Tester plugin into Core. There was broad agreement to at least explore this idea.

  • People click on things when they see them in an interface when they sound good.
  • There would need to be a way to revert to a stable release in case. Though this doesn’t currently exist and is not supported. Database migrations do not work in reverse.
  • Would this shoot the project in the foot by making it easier to opt-in to these development releases?
  • Cleaning up old files that never actually made it into a release could be a problem.
  • The risk of breaking live sites increases. This needs to be properly communicated and the project needs to be prepared to deal with these scenarios.
  • Allowing someone to opt-in to beta and RC releases is a low risk good first step.
  • It could be gated behind a constant in a way similar to multisitemultisite Used to describe a WordPress installation with a network of multiple blogs, grouped by sites. This installation type has shared users tables, and creates separate database tables for each blog (wp_posts becomes wp_0_posts). See also network, blog, site with WP_ALLOW_MULTISITE. At that point, would it be any different than testing features in Gutenberg or a feature pluginFeature Plugin A plugin that was created with the intention of eventually being proposed for inclusion in WordPress Core. See Features as Plugins?

Other Shared Thoughts

  • The project as a whole needs to be more clear about what type of feedback is desired (user feedback, technical feedback, etc.).
  • The path for turning on experimental features has gotten pretty complex in some cases. For example, the content policies experiment in Gutenberg requires the AI plugin as well as a connector to be installed and active. Sometimes experiments also require a specific patchpatch A special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. or pull request.
  • There could possibly be a way to opt-in to all experiments that ship in the Gutenberg plugin, including any added in the future.
  • It would be great to have a way to know how many sites are using each experiment.

Thoughts on Real-time Collaboration

An open floor was set for feedback about removing real-time collaboration from the WordPress 7.0 release.

  • The overwhelming majority of attendees agreed with the move to revert the feature for the 7.0 release.
  • There needs to be a clear list of criteria to be met before reconsidering. The reasons for removal were reasonable and real, but it’s not yet clear how to address each of those.
  • Some felt that the ball was dropped telling the story behind the feature. What would it actually mean in practice to users, especially those with a single user?
  • RTC could possibly enable a level of agentic AI functionality, but that is more likely to be made possible with the Notes feature.
  • There needs to be a final architectural decision that the project is comfortable standing behind and supporting long term.
  • Some expressed that they felt it had to go in and would no matter what because experienced names were called in to help address the shortcomings of the feature at the last minute.
  • It has been unclear at times how the feature fits into the overall goals of the project.
  • What does the delay of shipping RTC mean for the 4 phases of Gutenberg and the project’s current priorities?

Does The Feature Belong In Core?

A strong opinion, loosely held, was expressed and discussed: The full RTC feature set should not be in core, but the underlying architecture should be.

  • There is a lot of overhead being added with very little apparent gain at the moment.
  • Some of the YJS pieces and integrations must be in Core to actually work.
  • What if core only shipped with the WebSockets transport, with the 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. polling transport being the optional plugin given the scaling issues?
  • The feature could be added in two parts, similar to the REST APIREST API The REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/.
  • Who would maintain the parts that are merged into Core?
  • This approach could result in a new flavor of WordPress hosting with support for RTC. This could be frustrating for users if they change hosts and find the feature no longer works.

Recent Changes to Committercommitter A developer with commit access. WordPress has five lead developers and four permanent core developers with commit access. Additionally, the project usually has a few guest or component committers - a developer receiving commit access, generally for a single release cycle (sometimes renewed) and/or for a specific component. GitHub Capabilitiescapability A capability is permission to perform one or more types of task. Checking if a user has a capability is performed by the current_user_can function. Each user of a WordPress site might have some permissions but not others, depending on their role. For example, users who have the Author role usually have permission to edit their own posts (the “edit_posts” capability), but not permission to edit other users’ posts (the “edit_others_posts” capability).

One attendee mentioned that they no longer have the ability to bypass the required checks on pull requests in the Gutenberg repository (something that was previously possible). They were curious if their access had been adjusted or capabilities were adjusted. It was mentioned that there are a handful of other Committers who have reported differences in what actions they are able perform on GitHub (restarting Action workflow runs, etc.).

To the knowledge of everyone in attendance, there have been no intentional changes made to the WordPress Core team under the WordPress organization (which includes all Core Committers). It’s possible that something has changed on the GitHub side.

@desrosj and @johnbillion will investigate this and follow up in #core-committers.

Process Reminder for Assigning Commit-level Access

The group was reminded that since the bulk adjustment was made to sync the two groups in 2024, being a Core SVN committer is a requirement for being included in the Gutenberg Core team on GitHub. While this team is a subset of Core Committers, this must be followed for consistency in committer-level access across the two code bases and reinforcing the fact that “Core = Gutenberg, Gutenberg = Core”.

The team’s description on GitHub will be updated to reference this policy to make it harder to forget. The Core Handbook and documentation within the Gutenberg repository will be updated as well.

Summary

Attendees shared at the end that the meeting was very helpful for everyone to get on the same page. It was suggested that more frequent meetings (a mix of both virtual and in-person) for the group would be very beneficial.

Action Items

  • Address differences between svn:ignore properties and .gitignore rules through #64971.
  • Continue testing and iterating on the new build processes introduced during 7.0 and consider ways to improve these scripts further.
  • Be more communicative about any work being done/changes being considered, why they’re important, and the honest state of the efforts.
  • Think of ways to increase testing of every upcoming WordPress release. Follow up with proposals for suggested changes publicly.
  • Think of new ways to create and strengthen feedback loops to increase confidence in specific changes.
  • Seek clarity on the next steps and new acceptance criteria for Real-time Collaboration.
  • Investigate recent changes to the committer-level access on GitHub.
  • Consider ways for Core Committers to sync more frequently.

Props @dmsnell, @westonruter, @johnbillion for pre-publish review.

#core-committer-meetings, #core-committers

Dennis Snell 5:17 pm on June 10, 2026
Tags: , ,   

Call for Testing: Unicode email addresses.

Last month a call for input was sent concerning the introduction of Unicode email addresses for WordPress accounts (#31992). Initial support was merged in [62482]. Here is what you need to know in order to test this change on your sites and in your plugins and themes.

  • is_email() and sanitize_email() accept non-ASCII email addresses like grå@grå.org if the site database’s charset is utf8mb4.
  • Support is added as an enhancementenhancement Enhancements are simple improvements to WordPress, such as the addition of a hook, a new feature, or an improvement to an existing feature. which can be disabled by removing the is_email and sanitize_email filters for wp_is_unicode_email and wp_sanitize_unicode_email, respectively.
  • A new class — WP_Email_Address — provides a structural view into email addresses so your code doesn’t have to guess. It provides the local part, the domain part, and decodes Punycode translations in the domain part.

It should be possible, therefore, to create WordPress accounts with email addresses not previously allowed. In addition, email validation is updated to match the WHATWG email specification so that WordPress and an <input type=email> element will agree on what is and what isn’t allowable.

The term “Unicode email address” may be a bit ambiguous because there are two ways emails can be considered Unicode:

  • Unicode domain support has been supported for many years through Punycode encoding of the domain. This is an ASCII-encoded version of Unicode domains where the domain parts start with xn--, like xn--uist2j67d64zv30b.xn--ses554g as a stand-in for 慕田峪长城.网址. Because the encoding is all ASCII, WordPress has implicitly supported Unicode domains without recognizing them. The change in [62482] decodes the domain parts so that WordPress and its plugins and themes can access either the ASCII representation (for circumstances like HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. attributes where software will read their value) or the Unicode representation (for circumstances like text nodes where human will read their value).
  • Unicode local part (mailbox) support has largely been absent from specifications and software until recently when most major email hosts started routing mail with UTF-8 mailboxes. WordPress previously rejected all addresses containing non-ASCII characters. It now accepts valid UTF-8 local parts. There has never been an ASCII-encoding of this part of the email address.

If your extension code expects email addresses to only contain ASCII bytes, they will need updating for WordPress’ new Unicode email support. The easiest way to account for this is to use the new WP_Email_Address::from_string() and then access its getter methods.

// Generate an author link.

$email = WP_Email_Address::from_string( $provided_email );
if ( null === $email ) {
    return '';
}

$processor = new WP_HTML_Tag_Processor( '<a> </a>' );
$processor->next_tag();
$processor->set_attribute( 'href', "mailto:{$email->get_ascii_address()}" );
$processor->next_token();
$processor->set_modifiable_text( $email->get_unicode_address() );
return $processor->get_updated_html();

If your 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. connects with a third party service using email addresses from WordPress, now is a good time to ensure that third party also properly supports Unicode email addresses. If not, you can disable Unicode email support with the following snippet.

// Disable Unicode email support until third-party integration supports them.

remove_filter( 'is_email', 'wp_is_unicode_email', 10 );
remove_filter( 'sanitize_email', 'wp_sanitize_unicode_email', 10 );
add_filter( 'is_email', 'wp_is_ascii_email', 10, 3 );
add_filter( 'sanitize_email', 'wp_sanitize_ascii_email', 10, 3 );

Thank you!

This change updates existing email validation and sanitization code and introduces new behaviors for an unbounded set of potential email addresses. It’s likely that unanticipated cases will arise, and with your feedback in these cases, this feature can be a successful part of WordPress 7.1.

Props

Thanks to @amykamala and @jorbin for reviewing this post!

#call-for-testing, #email, #unicode

Amy Kamala 3:56 am on June 10, 2026
Tags: , , ,   

Dev Chat Agenda – June 10, 2026

The next WordPress Developers Chat will take place on Wednesday, June 10, 2026, at 15:00 UTC in the core channel on Make WordPress Slack.

The live meeting will focus on the discussion for upcoming releases, and have an open floor section.

The various curated agenda sections below refer to additional items. If you have ticketticket Created for both bug reports and feature development on the bug tracker. requests for help, please continue to post details in the comments section at the end of this agenda or bring them up during the dev chat.

Announcements 📢

CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress.

General

Discussions 💬

The discussion section of the agenda is for discussing important topics affecting the upcoming release or larger initiatives that impact the Core Team. To nominate a topic for discussion, please leave a comment on this agenda with a summary of the topic, any relevant links that will help people get context for the discussion, and what kind of feedback you are looking for from others participating in the discussion.

Open floor  🎙️

Any topic can be raised for discussion in the comments, as well as requests for assistance on tickets. Tickets in the milestone for the next major or maintenance release will be prioritized.

Please include details of tickets / PRs and the links in the comments, and indicate whether you intend to be available during the meeting for discussion or will be async.

#7-1, #agenda, #core, #dev-chat

Aaron Jorbin 3:35 pm on June 8, 2026
Tags: , , ,   

Call for WordPress 7.0.x Release Managers

WordPress 7.0.0 was released May 20, 2026. While the work of a major releasemajor release A release, identified by the first two numbers (3.6), which is the focus of a full release cycle and feature development. WordPress uses decimaling count for major release versions, so 2.8, 2.9, 3.0, and 3.1 are sequential and comparable in scope. team includes people filling many different positions, maintenance release teams generally are considerably smaller, often 1–3 people. Minor releaseMinor Release A set of releases or versions having the same minor version number may be collectively referred to as .x , for example version 5.2.x to refer to versions 5.2, 5.2.1, 5.2.3, and all other versions in the 5.2 (five dot two) branch of that software. Minor Releases often make improvements to existing features and functionality. managers are responsible for:

  • Triaging bugs in coordination with committers and component maintainers.
  • Drafting announcements for the release.
  • Preparing for and running release day activities.
  • Updating the documentation on minor releases so that it gets better each time.

Members of the 7.0 release cohort are encouraged to stay on as release managers for maintenance releases, but it is not required to have been on a major release squad in order to be on a minor release team.

WordPress 7.0.1 is tentatively targeted for release later in June 2026.

If you are interested in volunteering to be a release manager for the 7.0.x maintenance releases, please comment on this post or message me directly.

Props to @annezazu, @audrasjb, @wildworks for reviewing this post before publication.

#7-0, #7-0-1, #7-0-x, #maintenance

Jarda Snajdr 12:04 pm on June 5, 2026  

React 19 upgrade temporarily reverted in Gutenberg

Few days ago we announced that WordPress 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/ are upgrading to ReactReact React is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org 19. But soon after publishing a Gutenberg version with the upgrade (23.3.0) we discovered that many plugins that were built for the previous version of WordPress, with React 18, are incompatible with the new version and crash often.

While there are virtually 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 between React 18 and 19, the runtimes turned out to be incompatible in unexpected ways. For example, many plugins bundle their own version of the react/jsx-runtime helper used to process JSX syntax, but the shape of the generated objects (elements) is different, and React 19 actively checks and rejects elements generated by the React 18 runtime.

We’ll have to devise a better, less naive and more incremental upgrade strategy. With ability to switch between React 18 and 19 with an experimental feature flag, and with a compat layer for already released plugins. In the meantime, we decided to revert back to React 18, and released the revert in Gutenberg 23.3.2. This gives us time and breathing room to think the new strategy through and test it thorougly. We continue to be committed to doing the upgrade in WordPress 7.1.

Adam Silverstein 8:16 am on June 4, 2026
Tags: ,   

Call for Testing: client-side media processing

Client-side media processing is a progressive enhancementenhancement Enhancements are simple improvements to WordPress, such as the addition of a hook, a new feature, or an improvement to an existing feature. to WordPress’s existing server-based media pipeline. When a user uploads an image in 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, their browser decodes, resizes, and encodes all sub-sizes locally using the VIPS image processing library running in WebAssembly (via wasm-vips) before sending them to the server. Browsers that can’t handle the work silently fall back to the existing server-side path without user-visible errors.

The advantage of this approach is that we can provide a uniform, modern image processing experience across all WordPress sites without relying on server-side capabilitiescapability A capability is permission to perform one or more types of task. Checking if a user has a capability is performed by the current_user_can function. Each user of a WordPress site might have some permissions but not others, depending on their role. For example, users who have the Author role usually have permission to edit their own posts (the “edit_posts” capability), but not permission to edit other users’ posts (the “edit_others_posts” capability).. The client-side pipeline supports modern formats (AVIF, WebP, HEIC, UltraHDR, JPEG XL), offering better compression, and more consistent resizing quality regardless of hosting environment. It also reduces CPU and memory load on the server during image uploads by offloading the work to capable devices.

The feature graduated from a 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/ experiment to a coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Gutenberg feature during the 7.0 cycle and is now targeting WordPress 7.1 as a core capabilitycapability A capability is permission to perform one or more types of task. Checking if a user has a capability is performed by the current_user_can function. Each user of a WordPress site might have some permissions but not others, depending on their role. For example, users who have the Author role usually have permission to edit their own posts (the “edit_posts” capability), but not permission to edit other users’ posts (the “edit_others_posts” capability)..

With 7.1 on the horizon, the feature could use testing to help us shake out bugs, validate performance on real content and devices, and stress-test the new capabilities.

Tracking issues:

#76756 — Client Side Media iteration for WordPress 7.1

#74333 — Client Side Media iteration for WordPress 7.0 (previous cycle, closed)

What’s included in this round of testing

The 7.1 iteration tracked in #76756 builds on the 7.0 groundwork and adds several new capabilities. Highlights include improved format support, error handling and upload resilience.

A note on bundle size

Download weight and the lack of new capabilities was the biggest piece of feedback during the 7.0 cycle, so it has been a focus this iteration. Client-side processing now exceeds the format and quality capabilities of the best server-side setups, while loading less ahead of time than the 7.0 prototype

  • Nothing heavy loads up front. The WebAssembly image pipeline (wasm-vips and friends) is fetched on demand the first time a user uploads media – it is not part of the editor’s initial bundle.
  • New capabilities UltraHDR, HEIC and JPEGXL support, as well as the new GIF→video conversion feature, are all new capabilities and added minimal weight.

How to test

Please run through as many of the scenarios below as your environment allows, and report anything that looks wrong — slow, broken, unexpectedly falling back to server-side, visibly lower quality, etc. Test with the latest Gutenberg 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. and in a chromium browser for the feature to be active.

System and Browser Requirements

  • Non-Chromium browsers: Disabled by default because Firefox and Safari don’t support Document-Isolation-Policy. The HEIC canvas fallback still runs in Safari.
  • Low-memory devices: Devices reporting 2 GB of RAM or less are excluded.
  • 2g / slow-2g / Browsers sending the Save-Data header: Excluded because of the large worker download and increased upload bandwidth.
  • CSP restrictions: Sites with worker-src directives that don’t allow blob: fall back to server-side.

You can verify that the feature is active by checking window.__clientSideMediaProcessing in the browser console (should be true), or by looking for networknetwork (versus site, blog) requests to the sideload endpoint. You can also use this mini plugin to check the upload processing type (client or server) – it shows a label on the front end and adds a column to the Media library list view.

1. Baseline upload flow

  • Upload a handful of JPEGs, WebPs, HEICs, AVIFs, GIFs and PNGs (mix of sizes: ~500 KB, ~5 MB, and a >20 MB original) in the editor.
  • Confirm the Image block renders the uploaded image.
  • Verify all expected sub-sizes exist on disk.
  • Compare file sizes and visual quality to the same image uploaded using the media library (which uses server processing).
  • Test uploading avif, webp, heic, png (with various transparency and bit depths), and jpg files and confirm they are processed correctly.

2. HEIC (iPhone photos)

  • Upload a `.heic` image from an iPhone. Use your computer to do the upload (the iPhone’s uploader will automatically convert to JPEG before upload, so you won’t be testing the client-side features if you upload directly from the phone).
  • Confirm it is transcoded to a web format (JPEG/WebP/AVIF depending on your settings) and that sub-sizes are generated.
  • Confirm the original HEIC is also uploaded and preserved.
  • Confirm Portrait and Landscape HEICs work correctly.
  • Try a browser that lacks native HEIC decoding to verify the canvas fallback – see #76731 for browser support details.

3. Modern output formats (AVIF / WebP)

  • use the image_editor_output_format filterFilter Filters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. to output different formats from jpeg uploads.
  • test uploading avif, webp, heic, png (with various transparency and bit depths), and jpg files and confirm they are processed correctly according to the configured output format.
  • Upload a large JPEG and confirm sub-sizes are emitted in the configured format, including the -scaled variant.

4. Ultra HDR

  • Testable in #74873
  • Upload an Ultra HDR image (you can capture one on a recent Pixel or iPhone, or download samples from gainmap-js demos).
  • Confirm the gain map is preserved through resizing and that sub-sizes still render as HDR on a capable display/browser.

5. JPEG XL (JXL)

  • Testable in #77584.
  • Upload a `.jxl` image (sample gallery).
  • Confirm it is accepted and processed. Report any unexpected behavior.

6. Animated GIF → video

  • Ready to test once #76946 merges
  • Upload a large animated GIF.
  • Confirm it is converted to an MP4 or WebM (depending on implementation), and that the resulting block plays correctly in the editor and on the front end.

7. Batch and concurrent uploads

  • Drag-and-drop 10–20 images at once into the Image block or Media Library.
  • Watch for progress UIUI User interface, confirm all uploads complete, and check timing against a baseline where client-side is disabled.

8. Resilience

  • Test in #76765.
  • Use browser dev-tools to simulate a slow/flaky network during a batch upload and confirm retry behavior.
  • Try to save a post mid-upload and confirm the editor prevents or defers the save #76973.
  • Upload something, then refresh mid-upload — confirm the editor recovers cleanly.

9. Fallback paths

  • Test in a browser that does not meet capability requirements (Safari, Firefox)
  • Confirm the upload succeeds via the server-side path without user-visible errors. The only signal should be a developer-console message.

10. Extensibility

  • If you maintain a media-related plugin (image optimizers, DAM integrations, custom workflows), try it against a site with client-side media enabled.
  • Exercise the new filters/actions from #74913 and report any gaps.
  • Test disabling Client-side media.

11. Low-powered devices

  • Test on a low-end laptop, older Chromebook, or mid-range phone.
  • Confirm that the capability detection correctly gates the feature off when the device is underpowered and that processing does not lock up the browser.

Questions & bugs

Please report bugs by opening issues on the Gutenberg repo tagged with [Feature: Client Side Media]. Or, leave questions or comments on the tracking issue.

Thank you

Client-side media is a substantial shift in how WordPress handles images, and it only ships well with real-world testing across the full diversity of WordPress sites, browsers, and devices. Every report helps!

Props

Thanks to @jorbin and @ozgursar for reviewing this post!

#call-for-testing, #media

annezazu 7:29 pm on June 3, 2026
Tags: , , , ,   

Announcing a collaborative editing outreach effort for 7.1

A new dedicated outreach effort is underway for WordPress 7.1 to ensure collaborative editing gets the collaborative testing it needs. Please join #collaborative-editing-outreach in WordPress 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/ (steps to sign up here) if you:

  • Want to use collaborative editing on a regular basis.
  • Enjoy being an early adopter.
  • Feel comfortable using the latest version of 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/ 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..
  • Have the ability to participate through the 7.1 cycle (at least until 8/18/26).

Thanks in advance for helping shape the future of this feature.

Why now?

Collaborative features require an inherently collaborative way of testing. For the 7.0 cycle, a lot of time and effort was spent with more developer oriented testing, enterprise level testing, and deterministic testing with hosts. While incredibly useful, this effort broadens the scope of testing by bringing in passionate real-world early adopters across a range of hosting environments and backgrounds. For collaborative editing to truly succeed, it’s important to go beyond just getting stability, performance, and reliability right.

In running the FSE Outreach Program, I saw how powerful it was to have a dedicated space for folks to regularly interact with those building the feature for a faster feedback 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 in the right direction. After the hard decision was made to remove collaborative editing from WordPress 7.0, the aim is that ahead of 7.1 the outreach program model provides enough structure to create meaningful feedback without being too overbearing or exclusive considering the timeframe. This was first discussed in #feature-realtime-collaboration before being brought to project leadership. 

Who can join?

Anyone is welcome to join #collaborative-editing-outreach! Real Time Collaboration is included in the latest versions of Gutenberg, and can be enabled under `Settings > Writing` in the dashboard when the Gutenberg plugin is active.

It’s critical people from across different hosting environments and use cases are a part of this, from nonprofits to small businesses to newsrooms. If you have a large need for collaborative editing, enjoy sharing feedback, and are comfortable with using the latest Gutenberg plugin, this is an awesome way to contribute to the WordPress project. Test team badges will be given out at the end. 

More about the effort

The aim is to engage passionate real-world early adopters across a spread of hosting environments in a dedicated slack channel throughout the release process to ensure a tight feedback loop for both bugs and feature requests. This will take a simple form: a dedicated slack channel (#collaborative-editing-outreach) where folks can get set up with collaborative editing, share ongoing feedback, and those working on the feature can open bugs/make fixes/share improvements/etc. Compared to the FSE Outreach Program, there won’t be ongoing themed calls for testing since they would end up being very repetitive. Instead, key updates will be shared in the slack channel to help inform folks as new fixes or features are added to give feedback on them. The latest updates for collaborative editing will be delivered through the Gutenberg plugin which is why using the latest version is a requirement for this channel. As discussed here, a featured plugin isn’t currently feasible. 

Tied to this, outreach will be done to hosting companies to attempt to recruit participants for this outreach program. This is being done to help get as many different environments as possible represented. 

Currently, @amykamala, @greenshady, and I will be acting as the small crew driving this forward in the slack channel, alongside the developers and designers working on this feature. 

Questions? Comments? Concerns?

Please leave them below. Thanks for engaging.

Thank you to @amykamala @greenshady @maxschmeling for reviewing this post. 

#7-1, #collaboration, #feature-real-time-collaboration, #gutenberg, #phase-3
Amy Kamala 4:59 am on June 3, 2026
Tags: , , ,   

Dev Chat Agenda – June 3, 2026

The next WordPress Developers Chat will take place on Wednesday, June 3, 2026, at 15:00 UTC in the core channel on Make WordPress Slack.

The live meeting will focus on the discussion for upcoming releases, and have an open floor section.

The various curated agenda sections below refer to additional items. If you have ticketticket Created for both bug reports and feature development on the bug tracker. requests for help, please continue to post details in the comments section at the end of this agenda or bring them up during the dev chat.

Announcements 📢

7.1 Development

General announcements

Discussions 💬

The discussion section of the agenda is for discussing important topics affecting the upcoming release or larger initiatives that impact the CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Team. To nominate a topic for discussion, please leave a comment on this agenda with a summary of the topic, any relevant links that will help people get context for the discussion, and what kind of feedback you are looking for from others participating in the discussion.

Open floor  🎙️

Any topic can be raised for discussion in the comments, as well as requests for assistance on tickets. Tickets in the milestone for the next major or maintenance release will be prioritized.

Please include details of tickets / PRs and the links in the comments, and indicate whether you intend to be available during the meeting for discussion or will be async.

Props to @audrasjb for collaboration and review.

#7-1, #agenda, #core, #dev-chat

Arthur Chu 3:54 am on June 3, 2026
Tags: , , ,   

What’s new in Gutenberg 23.3? (03 Jun)

“What’s new in 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/…” posts (labeled with the #gutenberg-new tag) are posted following every Gutenberg release on a biweekly basis, showcasing new features included in each release. As a reminder, here’s an overview of different ways to keep up with Gutenberg and the Editor.

What’s New In
Gutenberg 23.3?

Gutenberg 23.3 has been released and is available for download!

This release ships the new modal-based media editor as the default cropping experience, advances the experimental customizable WordPress dashboard with five new widgets and significant layout polish, and upgrades the editor to ReactReact React is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org 19. Responsive styles now extend to individual 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. instances, and Notes blocks gain support for multiple discussion threads. Other changes include DataViews adopting @wordpress/theme design tokens, accessibilityAccessibility Accessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) refinements across the RevisionsRevisions The WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision. interface, continued Real-time Collaboration reliability fixes, and broader preload coverage for faster post editor loads.

Table of contents

Media editor modal becomes the default crop experience

The Media editor modal replaces the existing inline cropping tool in the Block Editor. The modal pattern keeps the familiar Crop button entry point, and brings freeform and aspect-ratio cropping, flip, fine-grained and snap rotation, and metadata editing into one dedicated workflow. (78653)

Experimental customizable WordPress dashboard

The experimental customizable WordPress dashboard — a widgetWidget A WordPress Widget is a small block that performs a specific function. You can add these widgets in sidebars also known as widget-ready areas on your web page. WordPress widgets were originally created to provide a simple and easy-to-use way of giving design and structure control of the WordPress theme to the user.-based surface available for testing behind an experimental flag in the Gutenberg 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., allowing users to add, move, resize, and rearrange widgets. It introduces a complete set of widgets — Welcome, Quick Draft, Activity, Site Health, Site Preview, and more — that automatically adapt to different tile sizes. You can fully customize your dashboard by choosing which widgets to display, arranging the layout, adjusting the number of columns, and resizing each widget’s width and height. (77616)

This change is experimental; to give it a try, first go to WP-Adminadmin (and super admin) > Gutenberg > Experiments and enable “New Dashboard experience”.

Responsive styles for block instance

Responsive styles for block instances (78384) building on 23.2’s responsive Global Styles, the Block Style States 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. extends to the per-instance level (76491). Block instance responsive styles include layout styles (78543) and an Inspector that shows only the relevant settings when a style state is selected. (78280) (78658, 78763, 78670, 78709)

Other Notable Highlights

  • Real-time Collaboration improvements — Notes blocks support multiple threads (75147), better handling of oversized payloads (>16 MiB) and connection-loss states (77724), protocol-mismatch error handling (76991), fewer refresh storms when peers edit (78483), and a mobile fix for Edit/Join row actions in the post list (78597).
  • DataViews adopts @wordpress/theme design tokens (75204) — the first significant in-codebase adoption of the design tokens package. A new “Introduction” Storybook page has been added for the tokens themselves (78449).
  • Accessibility wins — Image block gains a “Mark as decorative” toggle (78064); Revisions diff markers get higher-contrast stripes and scale with user text-size preferences (78473, 78273, 78393); Breadcrumbs block hides separators from screen readers (78524).
  • Performance — Optimized block-supports CSSCSS Cascading Style Sheets. class rendering (78217), lazy-fetched user pattern categories (78568), shared window listeners across block instances (78310), shared MediaQueryList listener in useMediaQuery (78297), and broader preload coverage on edit-post load (78508, 78565).
  • Components migrations — Continued 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 __experimentalText, __experimentalHStack, and __experimentalVStack to their stable @wordpress/ui counterparts (78155); Tooltip migration progressed across block-editor, editor, and DataViews consumers (78411, 78466, 78470).
  • React 19 upgrade (61521) — Gutenberg is now built against React 19. Most code keeps working unchanged; plugin authors using removed legacy patterns (string refs, ReactDOM.render fallbacks, defaultProps on function components) should review React’s upgrade notes.

Changelog

Features

Post Editor

  • Notes: Support multiple note threads per block. (75147)

Enhancements

Components

  • DataViews: Adopt @wordpress/theme design tokens. (75204)
  • Draggable: Scope the clone’s fallback z-index to non-slot placements. (78354)
  • Navigation: Hard deprecate component. (78529)
  • Overlays: Extend positioner slot pattern to Popover, Select, Autocomplete. (78168)
  • Tabs, TabPanel: Align styles with wp-ui. (78418)
  • Tooltip migration: Dataviews consumers (3/5). (78470)
  • UIUI User interface Button: Optimize overflow styles. (78300)
  • UI Card: Full bleed as 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. hero image and content cover. (77856)
  • Visually align Notice from @wordpress/components with Notice from @wordpress/ui. (78231)
  • [components] Draggable: Migrate clone wrapper to wp compat overlay slot. (78183)
  • [ui] Add internal wp compat overlay slot helper. (77851)
  • [ui] Autocomplete: Default portal container to the wp compat overlay slot. (78375)
  • [ui] Select: Default portal container to the wp compat overlay slot. (78372)
  • [ui] Tooltip: Default portal container to the wp compat overlay slot. (78095)
  • design-system-mcp: Add server instructions for client usage guidance. (78186)
  • design-system-mcp: Update get_components to optionally support multiple names. (78185)

Block Editor

  • Add support for layout responsive styles. (78543)
  • Add support for pseudo states on single block instances. (76491)
  • Block Inserter: Animate inserter button icon to signal open state. (78306)
  • Hide block variation selector when style state is selected. (78658)
  • Hide wrap by default in flex layout panel. (78269)
  • Integrate slug-based color selection in color panel. (78048)
  • Migrate pattern list item titles to Text from @wordpress/ui. (77656)
  • Refactor: Add extractPresetSlug as a generalized function to extract slugs. (78328)
  • Tooltip migration: Block-editor + block-directory consumers (1/5). (78411)
  • Validate additional CSS on mount. (78682)

Block Library

  • Block Style States: Show only supported inspector controls when selecting a style state. (78280)
  • Columns: Remove redundant Skip option from layout picker. (78405)
  • Hide Cover overlay controls for viewport states. (78763)
  • Hide image dimension tools when a state is selected. (78670)
  • Home Link: Add missing controls. (76672)
  • Move Layout panel into Styles tab so it sits next to Dimensions. (77922)
  • Responsive block instance styles. (78384)

Post Editor

  • Collab 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.: Swap near-identical pink for red in avatarAvatar An avatar is an image or illustration that specifically refers to a character that represents an online user. It’s usually a square box that appears next to the user’s name. palette. (78299)
  • Media Editor: Make the modal the default crop experience. (78653)
  • RTC: Provide PROTOCOL_MISMATCH error handling. (76991)
  • Tooltip migration: Editor + edit-post + edit-site consumers (2/5). (78466)

Media

  • Image cropper: Round zoom control values and display as percentages. (78757)
  • Media Editor Modal: Update the rotation ruler to use a vertical line marker. (78704)
  • Media Editor: Remove resize handles toggle from crop panel. (78758)

Dashboard

  • Add custom widget dashboard resize handle styling. (78236)
  • Dashboard Widgets: Adapt Quick Draft to its tile size with a recent drafts list. (78572)
  • Widget dashboard: Skip tile hover elevation while resizing. (78234)

Font Library

  • Clarify active variant state in Library tab. (78501)

Guidelines

  • Refine access policy. (78296)

Connectors

  • Restyle AI plugin callout with pastel background and beak. (78243)

Client Side Media

  • Add dimension validation to sideload endpoint. (74903)

Data Layer

  • Upgrade to React 19. (61521)

Bug Fixes

Components

  • @wordpress/ui: Compat overlay slot — viewport-sized containing block. (78441)
  • DataViews: Fix wrapper height resolution in flex layouts. (76945)
  • DataViewsPicker Table: Fix first-click row selection. (78423)
  • Fix FormTokenField validation preventing default behavior. (77181)
  • IconButton: Fix focusableWhenDisabled default. (78526)
  • Popover: Don’t close when focus moves into the @wordpress/ui compat overlay slot. (78407)
  • UI Button: Fix disabled cursor style. (78479)
  • UI: Fix item popup typography. (78403)
  • UI: Update Autocomplete clear disabled state. (78520)
  • useCopyToClipboard: Always call onSuccess callback. (78387)
  • useDialog: Handle Escape via React onKeyDown so cascade works through portals. (78433)

Block Library

  • Block/Tabs: Fix editor dirty state on reload by removing unnecessary mount-time attribute init. (78339)
  • Breadcrumbs block: Hide separator from screen readers. (78524)
  • Fix ‘Invalidinvalid A resolution on the bug tracker (and generally common in software development, sometimes also notabug) that indicates the ticket is not a bug, is a support request, or is generally invalid. Date’ when clicking on Now in DateTimePicker on Date Block. (78284)
  • Fix Tabs block losing added tabs when the editor is reopened. (78250)
  • Fix: Discard unsaved HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. block changes on cancel. (78580)
  • Image: Preserve width/height when converting Classic blocks to blocks. (78610)
  • Navigation Link: Preserve custom labels during link updates. (77186)
  • Navigation: Restore block_core_navigation_submenu_render_submenu_icon() as deprecated shim. (78484)
  • Prevent images from appearing squished when only one dimension is set. (70575)

Post Editor

  • Editor: Disable Visual Revisions when classic metaMeta Meta is a term that refers to the inside workings of a group. For us, this is the team that works on internal WordPress sites like WordCamp Central and Make WordPress. boxes are present. (78249)
  • Editor: Fix Visual Revisions meta keys overlap. (78156)
  • Editor: Use _n() for revisions count aria-label. (78382)
  • Fix image upload crashes. (76707)
  • Fix: Register user-defined taxonomies after user-defined post types. (78497)
  • Fix: Show collaborators when the top toolbar is active. (78049)
  • Global styles revisions: Ensure stylebook shows revision previews. (78490)
  • Script Loader: Defer single-page admin init until DOMContentLoaded (TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. #65103). (78136)
  • Upload Media: Render srcset on the front end for client-side-media uploads. (78359)

Block Editor

  • Block Inspector: Hide Styles tab in preview mode. (78230)
  • Block Toolbar: Prevent position shifts when using mover control. (77798)
  • Fix inconsistencies in feature selector processing part 2: Pseudo block instances. (78326)
  • Fix: Properly merge schema during mergeSchemas part in getBlockContentSchemaFromTransforms. (70615)
  • List View: Place caret at end of block when selecting. (76797)
  • Reset zoom level on component unmount. (69087)
  • Unset grid span defaults with viewport states enabled. (78709)

Data Layer

  • CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Data: Avoid duplicate ID-less entity permission requests. (78262)
  • Fix: Disable collab sync when incompatible meta boxes are present. (78145)
  • RTC: Fix cursor awareness / presence bugbug A bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. in nested rich text elements. (77673)
  • RTC: Fix block refresh on every update when a peer edits within the code editor. (78483)
  • RTC: Sync the content even if it’s a function. (76796)
  • Real-time Collaboration: Use minimal save payload in persistCRDTDoc. (77050)

Media

  • Media Editor Modal: Only show the crop active state when using keyboard. (78266)
  • Media Editor: Anchor cursorless zoom (slider/keyboard) at crop center. (78385)
  • Media Editor: Enforce a minimum crop size in the image editor. (78268)
  • Media Editor: Scope keyboard shortcuts to the modal. (78322)
  • Media Fields: Fix filename truncation with Tooltip. (78453)

Collaboration

  • RTC: Fix Edit/Join row action invisible on mobile in post list. (78597)
  • RTC: Fix connection lost error modal when /wp-json/wp-sync/v1/updates exceeds 16 MiB limit. (77724)

Global Styles

  • Fix block preview for responsive style states. (78538)
  • Fix inconsistencies in feature selector processing part 1: Global styles. (78276)

Client Side Media

  • Upload Media: Stop propagating -scaled to sub-size filenames. (78038)
  • VIPS: Remove dead batchResizeImage and vipsBatchResizeImage exports. (77975)

Paste

  • Keep <img> inside <a> when pasting plain-text HTML. (78015)

Testing

  • Tests: Temporarily disable REST index output-format assertions pending Core fix. (78788)

Accessibility

Post Editor

  • Image Editor: Focus return after closing image crop modal. (78711)
  • Revisions: Increase diff marker stripe contrast to 75% primary color proportion. (78473)
  • Revisions: Scale diff markers width with user text-size preference. (78273)
  • Revisions: Use CSS outline as secondary non-color indicator for diff blocks. (78393)

Block Library

  • Image block: Add “Mark as decorative” toggle for accessibility. (78064)
  • Image: Fix missing aria-label on lightbox trigger button for single images. (78426)

Performance

  • Block supports: Optimize custom CSS class rendering and parsing. (78217)
  • Fix performance tests when running against old reference commit. (78288)

Post Editor

  • Edit Post: Hoist setupEditor to run before root.render. (78581)
  • Edit Post: Consume preload cache before React mount. (78508)
  • Editor / Block Editor: Lazy-fetch user pattern categories. (78568)
  • Post Taxonomies: Drop redundant per_page: -1 from taxonomyTaxonomy A taxonomy is a way to group things together. In WordPress, some common taxonomies are category, link, tag, or post format. https://codex.wordpress.org/Taxonomies#Default_Taxonomies. queries. (78569)

Components

  • Blocks: Share window listeners across instances (block props, rich text, …). (78310)
  • Compose: Share a single change listener per MediaQueryList in useMediaQuery. (78297)
  • Compose: Simplify subscribeDelegatedListener root detection. (78492)

Data Layer

  • Core Data: Share parsed blocks cache between resolver and editor hook. (78026)
  • Edit Post Preload: Cover remaining bound GET/OPTIONS requests on load. (78565)

Commands

  • Core Abilities: Defer fetch until workflow palette opens. (78316)

Experiments

Dashboard

  • Add Quick draft widget. (78408)
  • Add chrome UI tools to widgets. (78060)
  • Add command palette commands. (78429)
  • Add dashboard Activity widget. (78552)
  • Add dashboard News widget. (78554)
  • Add dashboard Site Health widget. (78555)
  • Add dashboard Site Preview widget. (78556)
  • Add elevation to widget actionable area. (78563)
  • Add missing package file to the Site Preview widget. (78583)
  • Add Welcome dashboard widget with adaptive layout and content. (78461)
  • Add tooltip explaining disabled menu item. (78344)
  • Contain widget body within its tile to prevent page overflow. (78627)
  • Dashboard Widgets: Add content-bleed presentation variant. (78491)
  • Fix widget rendering on the masonry grid. (78645)
  • Full-size widget inserter. (78390)
  • Grid: Animate sibling tiles when layout reflows during drag or resize. (78395)
  • Grid: Animate tile removals. (78542)
  • Grid: Don’t allow resizing tile beyond min row height or column width. (78402)
  • Grid: Hide resize handles and actions while a tile is resizing. (78391)
  • Grid: Make resize overlay line solid. (78340)
  • Grid: Resize widget and snap resize-placeholder. (78389)
  • Grid: Tiled grid overlay. (78373)
  • Increase widget spacing with --wp-grid-gap. (78439)
  • Layered grid columns and visual layout model picker. (78364)
  • Layout settings drawer with grid/masonry models. (78202)
  • Migrate Layout settings drawer to DataForm. (78336)
  • Mobile improvements. (78522)
  • Per-instance widget settings drawer. (78465)
  • Polish dashboard drag preview motion, elevation, and drop exit. (78348)
  • Prevent pointer events in widget selection. (78681)
  • Quick Draft widget: Layout, empty state, and style refinements. (78601)
  • Refine widget actionable area toolbar styling. (78578)
  • Restrict widget icons to just SVGs (no Dashicons). (78440)
  • Round widget drag radius. (78292)
  • Scale widget picker previews to fill their card. (78602)
  • Seed default layout with bundled widget instances. (78622)
  • Small changes to header. (78513)
  • Tune default grid settings and starter layout. (78633)
  • Use Page hasPadding prop for content spacing. (78469)
  • Use fully-specified fast-deep-equal import. (78660)
  • Welcome widget: Add a subtle shine to the version digits. (78626)
  • Welcome widget: Draw the version number in the banner. (78611)
  • Widget Types: Declarative presentation hint (full-bleed support). (78209)
  • Widget Types: Generic attribute schemas. (78247)
  • Widgets: Declare dependencies in a per-widget package.json. (78463)

Media

  • Extract media editor crop options hook. (78263)
  • Extract media editor save hook. (78225)
  • Media Editor Modal: Add custom datetime view for the sidebar to ensure minimal display of dates. (78265)
  • Media Editor Modal: Fix unexpected tab stop on date fields in the Details sidebar. (78454)
  • Media Editor Modal: Tighten labels for crop handles toggle. (78703)
  • Media Editor Modal: Try placing the save and cancel buttons in the footer. (78708)
  • Media Editor: Harden cropper math layer against non-finite inputs. (78321)
  • Media Editor: Make zoom floor coverage-aware instead of fixed at 1x. (78222)
  • Media editor: Show live crop dimensions during gesture. (78221)
  • Refactor media editor crop state into composite reducer. (78480)

Block Library

  • Classic Block: Use get_post() in wp_declare_classic_block_necessary. (78613)
  • Media: Add undo snackbar for media editor image edits. (78425)
  • Update Classic block deprecation notice. (78445)

Post Editor

  • Add default term for taxonomies. (78233)
  • Add experiment to show admin bar in Post and Site Editor. (77964)
  • Media Editor Experiments: Tidy up by removing old pathways to the media editor experiment. (78489)

Block Editor

  • Grid: Fix immutability lint warning for React hook. (78431)
  • Grid: Visualize columns without outline. (78281)

Documentation

  • Docs: Add Workspace Development guide. (78615)
  • Docs: Update 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. editor migration guide for WordPress 7.0/7.1. (78401)
  • Docs: Update media editor documentation. (78617)
  • Theme: Add Tokens “Introduction” Storybook page. (78449)
  • Theme: Move token structure descriptions into tokens document. (78438)
  • UI Icon: Mark as recommended. (78365)
  • Update plugin release documentation and edit for clarity. (78537)
  • [ui] Trim verbose comments and prose around the compat overlay slot. (78356)

Code Quality

  • Migrate create-test-block.sh to @wordpress/validation-tools workspace. (78665)

Components

  • Add Badge text overflow end-to-end story. (78589)
  • DataViews: Inline z-index values. (78315)
  • Menu: Reduce flaky Space key test scope. (78246)
  • Modal: Inline header z-index. (78362)
  • Move @emotion deps out of root package.json. (78687)
  • RangeControl: Remove erroneous icon prop from web types. (78444)
  • Remove deprecated __experimentalApplyValueToSides export. (78528)
  • Routes: Enforce logical CSS properties in stylesheets. (78291)
  • Storybook: Add text overflow end-to-end stories. (78256)
  • Theme: Remove and prevent dependency grouping comments. (78573)
  • Theme: Update color space registration to avoid side effects. (77653)
  • UI Autocomplete: Fix prop types. (78450)
  • UI Tabs: Recommend component for use. (78442)
  • UI: Add Button variant states end-to-end story. (78634)

Post Editor

  • Deduplicate useGlobalStyles hook code. (78577)
  • Editor: Inline text editor toolbar z-index. (78309)
  • REST: Guard setAccessible() behind PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher < 8.1 in block-editor settings controller. (78478)
  • Use WCIcon alias for component Icon imports. (78366)
  • Use WCTooltip alias for component Tooltip imports. (78396)

Block Editor

  • Fix additional issues with block registration types. (78416)
  • Migrate __experimentalText, __experimentalHStack, and __experimentalVStack to Text and Stack. (78155)
  • Refactor: useMemo on elements and useCallback is back on resetAllFilter. (78329)
  • Simplify component ESLint rules and extend to routes/widgets. (78519)
  • Update the BlockAttribute typedef to allow for multi-type attributes. (78517)

Guidelines

  • Add data-slug attribute to settings list items. (78676)

Block Library

  • ESLint: Restrict deprecated __nextHasNoMarginBottom prop. (78579)

Media

  • Image editor: Remove unnecessary __nextHasNoMarginBottom prop. (78530)

Plugin

  • Connectors: Move from experimental to wordpress-7.0 compat. (78228)

Data Layer

  • Make RTC-related APIs private. (78097)

Tools

  • ESLint: Support private API component denylist. (78451)

Testing

  • Automated Testing: Allow console logging in all bin, scripts, tools files. (78312)
  • Automated Testing: Enable concurrency for ESLint. (78360)
  • Automated Testing: Fix and use built-in mechanism for flagging unused disables. (78313)
  • Automated Testing: Skip ESLint for bundled library code via ignore patterns. (78314)
  • e2e-test-utils-playwright: Add src to published NPM files. (78847)
  • Fix flaky end-to-end test with DataView keyboard navigation. (78503)
  • Fix flaky media upload save lock test. (78544)
  • Fix flaky navigation frontend submenu end-to-end test. (78270)
  • Fix flaky tests (publish-panel.spec.js focus assertion before panel close completed). (77893)
  • Guard PHP unit testunit test Code written to test a small piece of code or functionality within a larger application. Everything from themes to WordPress core have a series of unit tests. Also see regression. to avoid failures on old WP versions. (78547)
  • Perf tests: Capture loading durations before stopTracing(). (78294)
  • Perf tests: Disable Playwright tracing to remove snapshot overhead. (78295)
  • Perf tests: Save Chromium traces as CI artifacts. (77974)
  • Performance Tests: Log timestamps, optimize build overhead. (78237)
  • Performance tests: Fix template click, delete pages at startup. (78193)
  • Post Editor perf test: Remove unwanted actions from timed area. (78323)
  • Preload: Backportbackport A port is when code from one branch (or trunk) is merged into another branch or trunk. Some changes in WordPress point releases are the result of backporting code from trunk to the release branch. user global styles entry for classic themes on WP 6.9. (78546)
  • RTC: Add command to run in WebSockets mode. (78363)
  • Tests: Add timezone-mock to test/unit/package.json. (78277)
  • Tests: Add post-editor preload spec. (78318)
  • Tests: Preload spec — track query strings and use an existing draft. (78343)
  • WP Editor Meta Box e2e: Wait for TinyMCE init. (78631)

Build Tooling

  • (Release): Migrate bin/plugin into @wordpress/release-tools workspace. (77695)
  • Add cherry-pick script and update release tools in package.json. (78560)
  • Build Tools: Move build scripts to @wordpress/build-scripts workspace package. (78509)
  • Build: Detect stale node_modules at build/dev time. (77995)
  • Build: Remove custom job_status output in favor of native result. (78208)
  • Dashboard: Forbid non-module stylesheets in experimental, new widgets. (78496)
  • Fix path for license type detection in license.js. (78245)
  • Improve GHCR asset publishing and expand trigger events to include pull_request. (78211)
  • Move PHP Sync Issue Generator file to @wordpress/release-tools. (78456)
  • Publishing packages: Defer pushing tags until lerna publish succeeds. (78253)
  • Refactor validation tools and update related scripts. (77522)
  • Remove commander.js file from the project. (78400)
  • Remove dependency used for counting available CPUs. (78593)
  • Several improvements to the Dependabot configuration. (78536)
  • Stylelint: Add logical properties exemptions. (78252)
  • Update browserslist. (78840)
  • Widgets: Add TypeScript project configuration. (78467)
  • wp-build: Replace getter-based exports with data properties. (78303)

First-time contributors

The following PRs were merged by first-time contributors:

  • @allilevine: DataViews: Fix wrapper height resolution in flex layouts. (76945)
  • @CookieDarb: Build: Remove custom job_status output in favor of native result. (78208)
  • @danluu: RTC: Fix connection lost error modal when /wp-json/wp-sync/v1/updates exceeds 16 MiB limit. (77724)
  • @ecairol: Navigation: Restore block_core_navigation_submenu_render_submenu_icon() as deprecated shim. (78484)
  • @Raxen001: Migrate __experimentalText, __experimentalHStack, and __experimentalVStack to Text and Stack. (78155)
  • @rushikeshmore: Components: Fix FormTokenField validation preventing default behavior. (77181)
  • @SteveJonesDev: Image block: Add “Mark as decorative” toggle for accessibility. (78064)
  • @taipeicoder: RTC: Fix Edit/Join row action invisible on mobile in post list. (78597)
  • @yyppsk: Navigation Link: Preserve custom labels during link updates. (77186)

Contributors

The following contributors merged PRs in this release:

@aagam-shah @adamsilverstein @aduth @alecgeatches @allilevine @andrewserong @chriszarate @chubes4 @ciampo @CookieDarb @danluu @DarkMatter-999 @desrosj @dhruvikpatel18 @dpmehta @ecairol @ellatrix @fushar @gziolo @himanshupathak95 @im3dabasia @Infinite-Null @ingeniumed @jameskoster @joshualip-plaudit @jsnajdr @juanfra @karmatosed @kushagra-goyal-14 @lschuyler @MaggieCabrera @Mamaduka @manzoorwanijk @Mayank-Tripathi32 @mirka @Mustafabharmal @ntsekouras @paulopmt1 @prasadkarmalkar @R1shabh-Gupta @ramonjd @Raxen001 @retrofox @rushikeshmore @scruffian @shrivastavanolo @simison @SteveJonesDev @t-hamano @taipeicoder @talldan @tellthemachines @tyxla @USERSATOSHI @westonruter @yuliyan @yyppsk

#block-editor #core-editor #gutenberg #gutenberg-new

Aditya Dhade 5:18 pm on June 2, 2026
Tags: , , , ,   

Performance Chat Summary: 2 June 2026

The full chat log is available beginning here on Slack.

WordPress Performance TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. tickets

  • @b1ink0 asked about updates on #64471, which aims to add cross-document View Transitions on the frontend.
    • @westonruter shared that there is a bugbug A bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. with View Transitions in the WordPress adminadmin (and super admin) tracked in #65032. @westonruter also shared that PR #11912 is ready for review and addresses issues with the admin menu view transition animation.
    • @westonruter also highlighted #65294, which reports a temporary blank white screen that can appear when creating a new post.

Performance Lab 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. (and other performance plugins)

  • @westonruter shared that work is underway to fix #2437, which addresses deprecation warnings in the wp-env tests environment.

Open Floor

  • @nickchomey asked about opportunities to contribute to the Performance Team.
    • @westonruter suggested contributing to Performance Lab plugin maintenance, exploring open issues, and submitting pull requests.
    • @nickchomey expressed interest in PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher-based performance work and image optimization, particularly around the Image Placeholders plugin. @westonruter encouraged contributions in that area and suggested connecting with @adamsilverstein regarding related image optimization work.

Our next chat will be held on Tuesday, June 16, 2026 at 16:00 UTC in the #core-performance channel in Slack.

#core-performance, #hosting, #performance, #performance-chat, #summary