Teams
-
Core
The coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. team makes WordPress. Whether you’re a seasoned 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, 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., 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 or CSSCSS CSS is an acronym for cascading style sheets. This is what controls the design or look and feel of a site. developer or are just learning to code, we’d love to have you on board. You can write code, fix bugs, debate decisions, and help with development.
-
Design
The design group is focused on the designing and developing the user interface. It’s a home for designers and UXers alike. There are regular discussions about mockups, design, and user testing.
-
Mobile
The mobile team builds the iOSiOS The operating system used on iPhones and iPads. and Android apps. Lend them your Kotlin, Swift, or ReactReact React is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org Native skills. The team also needs designers, UXUX UX is an acronym for User Experience – the way the user uses the UI. Think ‘what they are doing’ and less about how they do it. experts, and testers to give users a smooth experience on every device.
-
Accessibility
The a11yAccessibility 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) group provides 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) expertise across the project. They make sure that WordPress coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. and all of WordPress’ resources are accessible.
-
Polyglots
WordPress is used all over the world in many different languages. If you’re a polyglot, you can help by translating WordPress into your own language or contributing to the GlotPress project, making translations easier and more effective for everyone.
-
Support
Answering questions in the support forums, IRC, or 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/ is one of the easiest ways to start contributing. Everyone knows the answer to something! Since the forums run on bbPress, you can also contribute by helping make the software behind them even better.
View all teams and their meetings
Latest activity
See the latest happenings across the entire project.
Training Team Meeting Recap – 17th November 2026
This meeting followed this meeting agenda in GitHub #3746, Meeting Agenda Post. You can see conversations from the meeting in this Slack Log. (If you don’t have a 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/ account, you can set one up.)
Introductions and Welcome
There were 23 attendees: @sonaliprajapati, @ravigadhiyawp, @snehal5774, @rfluethi, @hamadraja550, @pravin1996, @fahimmurshed, @dilip2615, @rjekic, @jenish1234, @dhruvang21, @sumitsingh, @andrewssanya, @huzaifaalmesbah, @makanikaran, @nikola93n (async), @VasantRajput (async), @nitspatel (async), @harshjadav003 (async), @webgrrrl (async), @courane01 (async), @clk87 (async), @upekar99 (async),
Newcomers: @Puchoweb
Meeting hosted by: @Devmuhib
Note Taker: @Harshjadav003
Note Reviewer: @VasantRajput
Welcome! Please post in the #training channel or reach out to a team member to help you with contributing. Resources to check out our onboarding program, and our Guide Program.
Contributor Updates
- What have you been working on, and how has it been going?
- @courane01: Testing WP 7.2, and running an audit on LearnWP content for things to revise or create to bring it current with 7.2
- Anything you’ve accomplished since the last meeting?
- @courane01: Showing up for the first time in a long stretch.
- Do you have any blockers?
- Can other contributors or Training Team members help you in some way?
Open Discussions
- Have you tried the new AI course created on the Learn platform?
- AI-Powered WordPress
- Have you tried to complete the course or just had a quick look at the content? What do you think about it?
- If you already have experience working with AI in WordPress, can you help us with Feedback – Free AI APIs on AI Powered WordPress Course #3686?
- We want to provide the best possible AI experience for everyone interested in working with AI in WordPress, including those who aren’t ready to pay for commercial models and agents.
News
Meeting Note Takers
Here is our current note taker roster:
- 17th November – @Harshjadav003
- 24th November – @Upekar99
- 1st December – @Alkesh7
- 8th December – Looking for Volunteer
- 15th December – Looking for Volunteer
Important note: If anyone needs to know more about Note Taking and need guide in creating a Recap Note Post then you can DM to @vasantrajput. He will guide you for a Recap Note and he will review & publish your Recap Post.
Looking for feedback
- We are proposing a community-driven review of the Learn WordPress Learning Pathways (User, Developer, and Designer) to identify outdated content and gather improvement suggestions from experienced WordPress users and contributors. Check out this post for details.
Looking for volunteers
- Translation Review Volunteers: We have a lot of lessons translated into many beautiful languages, but we need someone to review them and give us their opinion about the translation quality and possible improvements. Join us 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/ by following this link: https://github.com/WordPress/Learn/issues?q=is%3Aissue+state%3Aopen+project%3AWordPress%2F104.
- Content Review Volunteers: Volunteers are needed to review and identify content that should be updated or consolidated. Two groups are needed: one for the handbook and one for courses.
- Lesson Thumbnails: Work has started on creating thumbnails for lessons that need them. Team members are welcome to contribute to the remaining thumbnails through GitHub Issue #3428.
- Issue Cleanup: The team discussed organising the many open issues into smaller categories and reviewing them systematically.
- Review Workflow: The proposed process is to review issues one by one, identify outdated or irrelevant items, suggest next steps, and add comments before closing or updating issues.
- Good First Issues: Contributors can start with issues labeled Good First Issue, especially those related to content feedback, and follow the handbook guide for validating feedback.
- Issue Categories: The team discussed starting with a specific categoryCategory The ‘category’ taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging., with Bug issues suggested as a priority. Other options include Needs Translation Reviewer, Unlabeled, Awaiting Triage, and Content Feedback.
- Next Steps: Team members are encouraged to suggest which category should be reviewed first, after which the issues can be divided among contributors.
- Goal: Work together to clean up and keep the repository organised.
Updates from last week’s Triage Squad session
- No triage squad meetings last week
Other News
- We have updated the training team blog homepage. You can check from here: https://make.wordpress.org/training/
- Monthly Update: The Training Team’s October 2026 monthly update has been published.
- Community & Slack: The team shared the guide on how to bring your community to Make WordPress Slack.
- Andrew (@andrewssanya) has published the October Office Hours Meeting Recap: https://make.wordpress.org/training/2026/11/19/office-hours-meeting-recap-28-october-2026/
- We’re looking for Table Leads for 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 2027 #WCAsia 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://make.wordpress.org/support/handbook/getting-started/getting-started-at-a-contributor-day/. Sign up or nominate someone here: https://asia.wordcamp.org/2027/call-for-table-leads
Come and Contribute
This week’s contribution focus area
- Content ready for review: 9 issues. See Guidelines for reviewing content.
- Feedback awaiting validation: 37 issues. See Validating and Applying Content Feedback.
- Topics awaiting vetting: 2 issues. See Vetting Topic Ideas.
- Validated feedback awaiting fix: 27 issues.
Contribution Acknowledgement
- Badges awarded:
- Training Team Contributor Badge Awarded to @makanikaran
- Props:
- @sumitsingh: A huge shoutout and special thanks to @clk87, @rjekic, and @devmuhib for your amazing contributions, support, and collaboration!
Project updates
- @clk87 has redesigned the homepage of our Training Team blog! Huge congratulations to him on the great work. We’d love to hear your thoughts and feedback. Please share them in the discussion here: Proposal: Improve the top section of the Make WordPress Training Team homepage #3674
- A milestone to celebrate – WordPress Credits has reached over 50 institutions worldwide in just one year! Big shoutout to all organizers, mentors, and students. Learn more about it here: https://wordpress.org/news/2026/11/wp-credits-reaches-50/
Upcoming Online Workshops
- No workshop scheduled for this week.
If you have topics you’d like discussed in the meeting, please leave them in the Open Discussion section.
You can see all meetings scheduled on this meeting calendar. If you are new to the Training Team, then come walk through our onboarding program to get to know the team and how we work. And if you have questions, feel free to reach out in the #training Slack channel at any time.
PHP & WordPress chat: Nov 2026
Following the PHP conversation at WordCamp US, a group of WordPress and PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher contributors met on November 18th for a call to keep that discussion going. The aim was both to get to know each other better and to talk about important topics impacting our respective communities. What follows is a summary of the discussion. The call was held under the Chatham House Rule, so points are summarized without attribution, and nothing below should be read as a decision by either project.
Attendees
Names listed with consent. Anne McCarthy, Jason Adams, Eric Mann, Benjamin Eberlei, Jonathan Desrosiers, Elizabeth Barron, Sebastian Bergmann, Mike Auteri, Konstantin Obenland, Volker Dusch, Dennis Snell, Lynn Griffith, Jake Spurlock, Weston Ruter.
PHP 8.6 readiness
WordPress coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. is in good shape for 8.6. Two issues surfaced during testing:
- GD image flipping. Core historically flipped images by passing negative dimensions, a pattern that broke in 8.6. Core now uses the dedicated function instead. Plugins that copied the old pattern may still break.
- TrueType fonts were being reported with the wrong file type. That was fixed upstream in RC7.
Confidence in PHP 8.6 compatibility in the upcoming WordPress 7.2 release is high. 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. ecosystem remains the big unknown, and a developer note for 8.6 is being drafted for the Make WordPress Core blog to help extenders prepare.
A faster path between the projects
A recurring theme across meetings is that WordPress needs a way to say “we’ve noticed X, and it potentially could affect a lot of real sites” and have that land somewhere it will be seen. The PHP team is currently dealing with a large influx in AI generated 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. reports with hard to understand real world impact, which makes it genuinely hard to spot the issues affecting people. When talking about a way for the WordPress project to escalate without special treatment, it was made clear that if something impacts real users, the PHP team wants to know.
What was agreed in principle:
- Bugs still go to the PHP 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/ issue tracker. That remains the right front door to send things.
- On top of that, the PHP Foundation advisory board channel can act as a trusted path for WordPress to flag reports with demonstrated real-world impact, so they rise above the noise.
- WordPress will name one or two liaisons for a channel in the PHP Foundation’s 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 PHP contributors are invited into #core-php and the hosting channels in WordPress Slack. Existing PHP spaces include the PHP Foundation Slack and the PHP community Discord.
- There was also interest in a shared space spanning WordPress, Drupal, Joomla, and other large projects that rely on PHP for support issues, and in a similar line of communication with related projects, such as PHPUnit.
To make it easier to know “here is something that affects real people”, an idea was thrown out to point to an automated test that passes with current stable versions but fails with Alpha/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./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). of PHP-next. This makes it easy to both track the problem and understand clear impact.
Testing earlier and showing up in internals
WordPress core used to test against PHP nightly builds and stopped. The plan is to bring that back so regressions get reported well before beta rather than during it. Beyond testing, the clearest path to influence is participation in the PHP internals mailing list. The model to copy is Symfony who tests continuously against PHP’s main branchbranch A directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a “branch”, such as “the 4.0 branch”., reports regressions immediately, and takes part in the yearly deprecation discussions. Sustained participation is how a project earns a voice, and eventually how individual contributors earn RFC voting rights. Worth noting that this happens through individuals, and the PHP Foundation supports the health and funding of the project rather than setting technical direction.
There’s also a data gap worth closing. PHP’s backward compatibility checks typically run against the top 2,000–5,000 package repositories, which misses nearly all WordPress ecosystem code. WordPress can supply function usage data from the plugin directory, plus usage statistics from hosts, to inform deprecation decisions. Tooling for this already exists on the WordPress side (veloria.dev) and can be pointed at specific functions on request.
Getting sites off old PHP
To set the stage first, here’s some context around PHP versions:
- ∼14.5% of WordPress sites are still on PHP 7.4.
- ∼3% of WordPress sites are on PHP 8.0.
- ∼9% of WordPress sites are on PHP 8.1.
- PHP 8.2 is approaching the end of its security support.
WordPress does the work to support each new PHP release on day one, but its long support window means Core rarely gets to use new language features, and plugin developers feel the same squeeze. This results in friction both ways in adopting the latest and maintaining older versions. As one member said, “The ‘cool feature, I can’t wait to use it in 2-3 years’ is real.”
Part of the discussion centered around encouraging plugin developers to raise their own minimum PHP versions, which pulls site owners and hosts along behind them. A parallel problem exists in the 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 ecosystem, where the lack of a modern baseline across hosts blocks things like vector search and newer commerce protocols.
Security is the strongest and most salient message available right now. Recent vulnerabilities have made it clear that infrastructure management is no longer optional, and public awareness of security updates has never been higher with patching becoming an accepted fact of life across phones, devices, and appliances. The messaging is fairly simple around “if you’re on a supported version, you’re safer”.
In discussing what would be compelling to hosts, it was discussed how they tend to weigh risk against reward. Historically that meant downtime risk, licensing and control panel costs, and support ticketticket Created for both bug reports and feature development on the bug tracker. volume against the benefit of upgrading. The current climate lets hosts lead with security as the primary driver. Automated verification that a site will survive an upgrade remains hard because of the long tail of web applications but there might be a path to explore via WordPress Playground and site cloning approaches. For example, someone could use Reprint to clone their site into a WordPress Playground version running a more up to date version of PHP.
The topic came up of having a cross community interest group via the PHP Foundation centered on PHP upgrades that could cut across WordPress, Drupal, Joomla, Symfony, Laravel, etc. The PHP Foundation is seeing a steady influx of support requests for versions that are already unsupported which reflects how this is an ecosystem wide inertia problem rather than just a WordPress one.
PHP has no direct lever with hosts the way WordPress does with varying hosting channels. The PHP Foundation talks to sponsors and hosts mostly when issues come up on the mailing lists and hosts running old versions rarely engage upstream at all. Historically, it has helped to have built in pressure with the predictable support cycle (was every three years and now every four) which has forced hosts to either keep up to date or pay for extended support.
The plugin ecosystem
A few folks who had run large 7.4 8.x migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. said the same thing that outdated plugins were the bottleneck. Unfortunately, it tends to be the case that the authors behind them are precisely the ones nobody can reach. Developers who are active in the community already tend to keep their code current.
A range of ideas were thrown out for how to possible address this, along with concerns:
- More targeted outreach to plugin authors specific to PHP, using the same mailing list that’s used ahead of Core releases. Ideally, there could be a dedicated community manager that could surface what’s actually blocking authors (funding, contributors, time).
- Better static analysis feedback that tells an author “you need only X to be compatible with these newer versions”. Tide was meant to do this but it never reached its potential. Today, the Plugin Check tool covers some of it. Currently, failed compatibility checks 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. theme updates, but only severe security failures block plugin updates.
- Telling site owners what’s happening if a plugin is closed/removed as today the dashboard doesn’t tell the people running it.
- Exploring AI-assisted upgrades since for many plugins, compatibility is probably a small code change rather than a big refactor. This would be a tricky thing to do right without being too heavy handed.
- Plugin slugs are reserved permanently, so removal carries hijacking risk. Separately, registry operators in Europe may be liable for distributing known security problems.
Finally, it was noted how compatibility is a spectrum. A parse error is one thing and calling a function that no longer exists is another. Without comprehensive test suites, automated checks can only go so far.
Exploratory: sandboxing and required extensions
Two longer-horizon ideas came up for reducing what Core has to reimplement.
Adding a WebAssembly sandbox directly into PHP core. The argument made was that this belongs in core rather than as an optional extension, because frameworks can’t reliably build against something that may not be there. The payoff would be the ability to ship isolated, fast implementations of foundational standards handling (text encoding, HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers./XML parsing, image processing, URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org parsing) without waiting on platform upgrades, and to gate or isolate abandoned code. The mbstring case is illustrative: early versions have UTF-8 bugs, so WordPress polyfills multibyte functions in PHP, which is significantly slower than native execution.
The open question is cost under PHP’s shared-nothing model: binaries would need loading on every request, which could hurt on shared hosting. On the other hand, WordPress Playground already packages PHP itself into WebAssembly in a few megabytes, and a precompiled format loads fewer bytes and skips parsing stages compared to the equivalent userland code. Then again, it was wondered whether PHP polyfill implementations might be just as fast as the WASM module. Nothing was decided.
Making common extensions required was discussed since roughly 5% of hosts don’t have XML or Zip enabled, which forces WordPress to reimplement them. Bundling these as mandatory core dependencies in a future release (8.7 was floated) would remove that burden, which would give WordPress a concrete reason to raise its minimum supported version more aggressively.
AI
AI came up repeatedly, cutting both ways. It’s flooding the PHP tracker with low impact reports and making it harder to see real issues. It raises real concerns about chained vulnerabilities in generated code. And at the same time, it’s now capable of modernizing very large legacy codebases to current PHP in hours, which may be the single biggest practical lever on the upgrade problem. Both communities are working out what helpful versus unhelpful AI contribution looks like, and there was clear interest in comparing notes rather than each solving it alone.
Next steps
Names listed with consent.
- Add PHP nightly back to the WordPress core test suite (@desrosj)
- Share a short list of WordPress folks to join the appropriate PHP channels, and connect PHP contributors into WordPress Slack (@annezazu)
- Publish the WordPress developer note for PHP 8.6 (@desrosj)
- Explore a cross-project interest group on PHP upgrades with PHP Foundation support (Elizabeth Barron/@annezazu)
- Explore ways to flag incompatible plugins, reach plugin authors more proactively, and add more to the plugin checker to help folks.
Props to everyone who joined and to @desrosj and @westonruter for reviewing these notes.
WordPress 7.2 Field Guide
This guide outlines major developer features and breaking changes in 7.2 and is published during the Release Candidaterelease 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). phase to help inform WordPress extenders, CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. developers, and everyone else interested in the latest WordPress development.
There are more than 440 Core Trac tickets included in WordPress 7.2, almost 150 of which are enhancements and feature requests, and more than 260 bug fixes. This release includes 40 tickets focused on the Editor. Across all tickets, the most attention went to the accessibility (48), tests (34), and performance (26) focuses. Additionally, this release includes almost 700 enhancements and nearly 500 bug fixes coming from 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/ (versions 23.7 through 24.3).
A quick search of the diff between 7.1.4 and the current trunktrunk A directory in Subversion containing the latest development code in preparation for the next major release cycle. If you are running “trunk”, then you are on the latest revision. (7.2-RC1) reveals 21 new hooksHooks In WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same. (16 filters and 5 actions), 2,947 total files changed with 246,673 insertions and 51,993 deletions. Kudos to everyone who contributed to the 7.2 release!.
Below is a breakdown of the most important developer-related changes included in WordPress 7.2.
Media
WordPress 7.2 expands the client-side media processing 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). introduced in WordPress 7.1, bringing support to additional media upload interfaces and improving the handling of animated images.
Client-side media processing
Client-side media processing is now available in the Media Library grid, Add New Media File screen, and media modal, in addition to 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. This allows supported image operations, including resizing, format conversion, and sub-size generation, to take place in the browser rather than on the server.
Client-side processing is supported in Chromium-based browsers, including Chrome 137 and later and Edge 137 and later. Firefox and Safari do not currently support the required Document-Isolation-Policy and automatically fall back to server-side processing. Even in supported browsers, client-side processing requires more than 2 GB of device memory, sufficient processing capabilities, and compatible security settings. When these requirements are not met, WordPress uses the existing server-side upload process.
For additional details about browser compatibility, requirements, and fallback behavior, see the Client-Side Media Processing documentation.
Cross-origin isolation
WordPress 7.2 updates cross-origin isolation handling and deprecates wp_start_cross_origin_isolation_output_buffer() and wp_add_crossorigin_attributes().
The new wp_send_document_isolation_policy_header() function replaces the former, while the latter has no direct replacement. Developers who customize cross-origin isolation behavior or modify script attributes should review these changes.
Administration
SVG icons in the adminadmin (and super admin) bar and menu
WordPress 7.2 continues the modernization of administration interfaces by replacing Core Dashicons font glyphs in the admin menu and admin bar with inline SVG icons.
This builds on the SVG Icon 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. introduced in WordPress 7.1, providing a more consistent icon system throughout the administration interface.
Most existing plugins and themes will continue working without modification. However, custom admin color schemes, icon replacements, and CSSCSS Cascading Style Sheets. targeting Dashicons pseudo-elements may require updates to accommodate the new SVG markup.
Developers can use registered, namespaced SVG icon names in administration menus and toolbar nodes. The new icon argument for WP_Admin_Bar::add_node() provides a standardized way to specify toolbar icons.
The developer note includes detailed compatibility guidance for custom admin color schemes, CSS selectors, icon replacements, and modifications to Core admin bar nodes.
Blocks and Global Styles
Text Shadow block support
Building on the text shadow styling capabilities introduced in WordPress 7.1, WordPress 7.2 adds textShadow typography block support, text shadow presets, and editor controls.
The Paragraph and Heading blocks support text shadows by default. Custom blocks can opt into the feature by declaring supports.typography.textShadow in their block.json metadata.
Theme authors can define custom text shadow presets through settings.typography.textShadowPresets in theme.json. These presets are available through Global Styles and the Typography panel of supported blocks.
WordPress includes two default presets, Light and Strong. Themes can customize or disable the defaults, and preset values are exposed through generated CSS custom properties and utility classes.
The styles.typography.textShadow property introduced in WordPress 7.1 also supports preset references in 7.2, allowing themes and blocks to use shared text shadow definitions.
Editor
WordPress 7.2 introduces changes to editor interfaces and component libraries, improving consistency with the WordPress Design System while providing new functionality and migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. paths for 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. developers.
Options and View menus
The Options and View menus in the post and site editors now use the Menu component from @wordpress/ui.
The updated menus provide improved keyboard navigation, 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) semantics, and more consistent interactions with other WordPress interface components.
Existing integrations using PluginMoreMenuItem, PluginSidebarMoreMenuItem, and PluginPreviewMenuItem remain supported. However, plugin menu items now appear in a Panels submenu, and the previously undocumented as prop is deprecated and ignored.
Developers with custom menu styling or automated tests targeting the previous component markup should review their implementations, particularly selectors that depend on @wordpress/components classes.
Editor components
WordPress 7.2 completes the migration of @wordpress/components from Emotion to SCSS Modules, reducing styling runtime and build overhead.
Most integrations using documented component properties and className will not require changes. However, developers relying on Emotion-specific behavior, generated class names, or custom styling implementations should review the migration guidance.
The release also introduces changes to FontFamilyControl styling and adds a presentation prop to ColorPalette, GradientPicker, and DuotonePicker, providing more explicit control over swatch interaction and accessibility semantics.
The existing asButtons prop is deprecated in favor of presentation.
Several components are also deprecated, with removal scheduled for WordPress 7.4:
AnimateDividerElevationResponsiveWrapperScrollableSurfaceTipZStack
Developers should review the recommended alternatives and begin migrating existing implementations.
CSS module class name collisions
WordPress 7.2 includes changes to the build process for several @wordpress/* packages to prevent CSS module class name collisions when different versions of the same package are loaded on a page.
Previously, bundled copies of packages could generate identical CSS class names despite containing different styles. This could cause styles from one package version to affect components from another.
The updated build process ensures CSS module class names change when their corresponding CSS changes.
Plugin developers bundling their own copies of affected packages should update to the fixed versions or later:
@wordpress/ui— 0.26.0@wordpress/dataviews— 22.0.0@wordpress/admin-ui— 3.1.0@wordpress/grid— 0.11.0@wordpress/components— 44.0.0
Plugins compiling CSS modules using @wordpress/build should update to version 0.27.0 or later and rebuild their assets.
Plugins loading @wordpress/components through the shared wp-components script will receive the corrected version included with WordPress 7.2.
Style state-aware block styling controls
WordPress 7.2 introduces a public API for custom block styling controls to read and update styles for the currently selected viewport or pseudo state in the block editor.
The @wordpress/block-editor package provides the getSelectedBlockStyleState and hasSelectedBlockStyleState selectors to determine the selected state, along with the getStyleForState() and setStyleForState() helpers for reading and updating the corresponding block styles.
Developers can use the new style-state group in InspectorControls to display custom controls when a viewport or pseudo state is selected. The same group is also available in BlockControls for displaying toolbar controls when a viewport state is active.
For integrations requiring viewport media queries, the @wordpress/global-styles-engine package exports getViewportMediaQueries(), while PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher developers can use the corresponding wp_get_viewport_media_queries() function. Both support custom breakpoints and use Core defaults of 480px for mobile and 782px for tablet when no values are supplied.
These additions allow custom block controls to integrate with responsive and state-aware styling without implementing separate mechanisms for managing style attributes.
Abilities API
Permissions, input handling, and 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. output
WordPress 7.2 introduces several improvements to the Abilities API, making permission checks, input handling, and JSON responses more consistent across execution paths.
The new required_capabilities registration argument allows developers to declare capabilities that must be satisfied for every execution of an ability. These are checked before the permission_callback, which can now be omitted when the declared capabilities fully cover the ability’s permission requirements. The new has_required_capabilities query argument also allows abilities to be filtered during discovery based on the current user’s capabilities.
Input handling is now standardized through WP_Ability::prepare_input(), which normalizes, validates, and sanitizes input according to the registered schema. Both direct PHP execution and REST requests use this preparation process, ensuring callbacks receive consistent values. Developers calling check_permissions() directly must prepare input first, while sanitization failures now return an ability_invalid_input error rather than falling back to unsanitized values.
WordPress 7.2 also introduces wp_prepare_json_value_for_client() and updates wp_prepare_json_schema_for_client() to preserve the distinction between JSON objects and arrays. Empty values declared as objects are serialized as {} rather than [], including nested values. Developers implementing custom transports should use these helpers when preparing ability results for JSON output.
Plugin developers should review existing permission callbacks, input type assumptions, and JSON response handling, particularly when maintaining compatibility with earlier WordPress versions.
Interactivity API
New HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. rendering and navigation capabilities
WordPress 7.2 introduces several improvements to the Interactivity API, including a new directive for rendering HTML, additional client-side navigation state, and the removal of previously deprecated behaviors.
The new data-wp-html directive allows developers to render HTML from the Interactivity API store. Values must be explicitly marked using asDangerousHTML() 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 or wp_interactivity_as_dangerous_html() in PHP.
These functions do not sanitize HTML, so developers must ensure that content is trusted and appropriately sanitized before rendering it.
The core/router store also introduces state.navigating and state.initiator, allowing blocks to determine when client-side navigation is occurring and identify the region that initiated it.
Several previously deprecated behaviors have been removed, including data-wp-ignore, two-hyphen unique directive identifiers, and negation of function references in directives.
Developers relying on these behaviors should update their implementations to maintain compatibility.
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/
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., comments, and CORS handling
WordPress 7.2 introduces three REST API changes affecting revision metadata, comment status parameters, and Cross-Origin Resource Sharing (CORS) headers.
Revision and autosave responses now include only metadata registered for revisions. This prevents metadata that is not revisioned from being inadvertently overwritten when restoring content.
Developers can enable revision support for registered metadata using revisions_enabled or the wp_post_revision_meta_keys 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..
The comments endpoint now handles the status parameter as an array rather than a string. Plugins and integrations that inspect or modify this parameter should review their implementations.
Additionally, the new rest_allowed_cors_methods filter allows developers to customize the Access-Control-Allow-Methods response 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.. REST responses that explicitly set this header will retain their specified value.
These changes are particularly relevant to plugins that interact directly with revision metadata, customize REST API requests, or manage cross-origin requests.
Rewrite API
Random content redirects
WordPress 7.2 introduces a new /random/ endpoint that redirects visitors to a randomly selected published post.
The feature integrates with existing rewrite rules and query APIs, supporting random content discovery across eligible post types, taxonomies, and author archives.
Custom post types can control participation through the new randomable argument in register_post_type().
Developers can customize random content queries using existing query hooks and the new wp_is_random_content_query() helper. The wp_enable_random_content_redirect filter can disable the feature entirely.
The random URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org base is configurable through Permalink Settings, providing flexibility for sites with different URL structures.
Database
Changes to supported SQL modes
WordPress 7.2 adds NO_BACKSLASH_ESCAPES to the list of incompatible SQL modes disabled when WordPress establishes a database connection.
WordPress relies on backslashes when escaping special characters in SQL queries. Enabling NO_BACKSLASH_ESCAPES can cause queries to fail or produce unexpected results, particularly on hosting environments that enable this mode by default.
The change is applied to the WordPress database session through wpdb::set_sql_mode() and does not modify server-wide SQL settings.
Developers who explicitly require this mode can modify the existing incompatible_sql_modes filter through a db.php drop-in, although doing so may introduce compatibility issues with Core.
External Libraries
Preparing for jQuery 4
WordPress 7.2 updates jQuery Migrate to version 3.6.0 as part of ongoing preparations for a future upgrade to jQuery 4.
The updated jQuery Migrate library helps developers identify deprecated functionality and compatibility issues in plugins and themes before the eventual transition.
The current roadmap tentatively targets WordPress 7.3 for updating jQuery and related dependencies, subject to testing.
Disabling jQuery Migrate by default is planned for a later release, potentially WordPress 7.5 or 7.6, depending on testing and the impact on the ecosystem.
Plugin and theme developers are encouraged to test their JavaScript against the updated library and address deprecation notices in preparation for these changes.
WordPress 7.2 does not include jQuery 4 itself.
But wait, there’s more!
WordPress 7.2 also includes numerous smaller enhancements, 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. fixes, and improvements across Core and the block editor.
For a complete list of changes, see the WordPress 7.2 milestone in Core Trac and the Gutenberg repository.
Miscellaneous Core Changes
WordPress 7.2 includes a number of smaller developer-facing changes across administration, metadata, application passwords, permalinks, script loading, and automatic updates.
This dev notedev note Each important change in WordPress Core is documented in a developers note, (usually called dev note). Good dev notes generally include a description of the change, the decision that led to this change, and a description of how developers are supposed to work with that change. Dev notes are published on Make/Core blog during the beta phase of WordPress release cycle. Publishing dev notes is particularly important when plugin/theme authors and WordPress developers need to be aware of those changes.In general, all dev notes are compiled into a Field Guide at the beginning of the release candidate phase. covers changes that may affect plugins, themes, custom integrations, and development workflows but do not require separate developer notes.
Miscellaneous Editor Changes
WordPress 7.2 includes several smaller changes to the Block Editor and Core Data packages, including the removal of deprecated properties, adjustments to stylesheet locations, improved handling of block-level custom CSS, and more efficient data store subscriptions.
The __experimentalGroup prop has been removed from InspectorControls and InspectorControls.Slot. Developers should use the stable group prop instead, which has been available since WordPress 6.2. Existing implementations using __experimentalGroup will now render controls in the default settings group rather than their intended panel.
The deprecated __experimentalImageEditor component has also had its stylesheet moved from @wordpress/block-library to @wordpress/block-editor. Developers still using this component should update their stylesheet imports.
Additional CSS defined in a block’s Advanced panel now applies to blocks rendered by their parent, such as Navigation Link blocks within a Navigation block. No code changes are required, but previously ignored CSS rules may now take effect.
Finally, registry.subscribe( listener, storeName ) now handles subscriptions to unregistered stores more efficiently. Listeners are connected to their specified store when it becomes available, rather than receiving updates from every registered store.
Thank you to everyone who contributed to this version of WordPress, whether through code, testing, or something else – your contributions matter and help Make WordPress.
Props to @amykamala, @adamsilverstein, and @audrasjb for peer review.
The Move Is On! GatherPress Migration FAQs
Our first pilot groups are making the move from Meetup.com to groups on events.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/, powered by GatherPress! The community has been working toward this for years, and we’re finally seeing it come together.
The timeline so far:
2018: @mauteri and @cameronbarrett dream up GatherPress while driving to WCUS
2020: GatherPress lands on Github
2024: @patricia70 makes a case for the community
2025: Groups begin testing, separately
2026: Integration announced, and work begins
And now we’re here, migrating our first groups. This is a huge milestone. Here are the questions we’re getting as we go.
Frequently Asked Questions:
Q: Why are we moving?
A: Meetup.com has served our groups well for over a decade, but it has always been borrowed space. Bringing our events to our own open sourceOpen Source Open Source denotes software for which the original source code is made freely available and may be redistributed and modified. Open Source **must be** delivered via a licensing model, see GPL. platform gives us the opportunity to build a true home for our community. Members sign in with WordPress.org, community data stays with us, money spent on the platform can be reinvested in the community, and we get to shape the experience ourselves.
Q: How do we get started?
A: Come join us in the #gatherpress-migration channel on Making 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/! We’re still refining the process as we go, so things will evolve a bit as we learn from each migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies.. You can find the latest process guide right here.
Q: Will our groups be smaller after the move?
A: You’ll probably notice a drop in your member count, so let’s talk about it. Across all of our groups, only about 1 in 20 members logged in and RSVP’d over the past year. On average, we’ll import about three times that. We’re bringing over your most engaged members and then some.
We’re also giving everyone else an opportunity to create a WordPress.org account or join their new group directly before each import. We want to make sure people have a chance to come along, even if they haven’t been active recently. With accounts here, they’re connected to local events as well as the global WordPress community.
Q: How is member privacy protected?
A: We take privacy seriously. We only import members whose email address matches an existing WordPress.org account, and only after giving them two weeks’ notice and an opportunity to opt out. We never automatically create accounts or enable unsolicited notifications. Unmatched data is discarded, and member lists are only visible to logged-in users.
Q: How will people find our events?
A: Events are highlighted on events.wordpress.org, and appear directly inside the WordPress dashboard for millions of WordPress users. We even have some handy tools for creating promotional flyers!
We know event discovery is a big part of making this transition successful, and it’s something we’re continuing to improve. We’d love to hear what’s working for your group, and where you think we could do better.
Q: What happens to our Meetup.com group?
A: Once your group is comfortably settled into its new home, we’ll work with you to figure out the right timing to close your old Meetup.com page. Ultimately, we want to make sure our community has a secure, official home and that members know where to find us.
Q: Where are translations handled?
A: Strings for each locale can be translated here.
That’s what I have for now! But I’m guessing you have more questions, so please send them in here! Or drop by in #gatherpress-migration on Making WordPress Slack. We’d love to hear from you!
This is a big step toward reconnecting local WordPress communities, both with each other and with the wider global project. It’s taken a lot of people and a lot of work to get here. Cheers to everyone who has helped make this happen, especially every GatherPress contributor and champion, along with @dd32, @bor0 and his team, and everyone who has helped with testing.
Miscellaneous Developer Changes in WordPress 7.2
WordPress 7.2 includes a number of smaller developer-facing changes that are not covered by a dedicated developer note. This post collects them, along with any compatibility considerations for plugins, themes, and hosting environments.
Users and Application Passwords
Email notification when an application password is created
When an application password is added to a user account, WordPress 7.2 sends an email to that user. The new wp_application_password_created_notification() function is hooked to the existing wp_create_application_password action. The email is sent whenever WP_Application_Passwords::create_new_application_password() succeeds, whether the password was created from the profile screen, the Authorize Application screen, 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/, or by a direct call to the method.
No email is sent when the user does not exist, when the user’s email address is not valid, or when the application password has no name.
Two filters control the notification:
wp_send_application_password_created_email(bool $send, WP_User $user, array $new_item) decides whether the email is sent.wp_application_password_created_email(array $email, WP_User $user, array $new_item) filters theto,subject,message, andheadersvalues passed towp_mail().
The message supports these placeholders, which are replaced after the 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. runs: ###USERNAME### (display name), ###APPLICATION_PASSWORD_NAME###, ###ADMIN_EMAIL###, ###EMAIL### (the user’s email address), ###SITENAME###, and ###SITEURL###. The subject is passed through sprintf() with the site title, so a filtered subject should keep its %s placeholder and escape any literal percent sign as %%.
$new_item holds the stored details of the new password: uuid, app_id, name, password (a hash, not the plain-text password), created, last_used, and last_ip.
// Skip the notification for passwords created by a specific application.
add_filter(
'wp_send_application_password_created_email',
static function ( $send, $user, $new_item ) {
if ( 'b1c4a7e2-5f3d-4e8a-9c21-7d6f0e3b2a14' === $new_item['app_id'] ) {
return false;
}
return $send;
},
10,
3
);
// Add a line to the notification.
add_filter(
'wp_application_password_created_email',
static function ( $email, $user, $new_item ) {
$email['message'] .= "\n\n" . sprintf(
/* translators: %s: Profile screen URL. */
__( 'Review application passwords: %s', 'my-plugin' ),
admin_url( 'profile.php' )
);
return $email;
},
10,
3
);
To turn the notification off completely, return false from wp_send_application_password_created_email, or remove the callback:
remove_action( 'wp_create_application_password', 'wp_application_password_created_notification' );
Sites that send their own notification for new application passwords may want to disable one of the two.
For more information, refer to #63927, r63582, and r64253.
Application password data passed to hooksHooks In WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same. is now unslashed
WP_Application_Passwords::create_new_application_password() and WP_Application_Passwords::update_application_password() expect slashed data. CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. callers have always passed it: the REST API controller wraps its input in wp_slash(), and the Authorize Application screen passes values from $_POST. Before 7.2, the methods passed that slashed data to their actions unchanged, so a name such as Bob's App reached callbacks as Bob\'s App. It also appeared that way in the new notification email.
In WordPress 7.2:
- Both methods call
wp_unslash()on their input before using it. - The
wp_create_application_passwordaction receives unslashed$new_itemand$argsvalues. - The
wp_update_application_passwordaction receives unslashed$itemand$updatevalues. - The
$new_itemarray returned bycreate_new_application_password()is unslashed. - The protected
set_user_application_passwords()method now slashes the passwords before callingupdate_user_meta(). Backslashes in stored names are kept when another application password on the same account is created, updated, used, or deleted. Previously they could be stripped by any later save.
Compatibility considerations:
- Callbacks on
wp_create_application_passwordorwp_update_application_passwordthat callwp_unslash()themselves should stop doing so. Otherwise they will strip real backslashes from the values. - Code that calls
create_new_application_password()orupdate_application_password()with raw, unslashed values should wrap them inwp_slash(). This matches the documented contract (Expected to be slashed) and is unchanged from earlier versions, whereupdate_user_meta()unslashed the stored values. Unslashed input containing backslashes loses them either way.
$created = WP_Application_Passwords::create_new_application_password(
$user_id,
wp_slash(
array(
'name' => $name,
'app_id' => $app_id,
)
)
);
For more information, refer to #63927 and r65361.
Bootstrap/Load
WP_DEBUG is enabled by default for the local environment type
When WP_DEBUG is not defined, wp_initial_constants() now sets it to true when the environment type is local, as it already did for development. The defaults are now:
| Environment type | Default WP_DEBUG |
|---|---|
local | true (previously false) |
development | true |
staging | false |
production | false |
As before, WP_DEBUG is also true whenever a development mode is set through WP_DEVELOPMENT_MODE.
This only affects sites where WP_ENVIRONMENT_TYPE is set to local, as a constant or an environment variable, and WP_DEBUG is not defined. A value defined in wp-config.php still takes precedence.
WP_DEBUG_DISPLAY still defaults to true, so these sites will now display PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher notices, warnings, and deprecation messages. As before, wp_debug_mode() turns off display_errors for REST API, Ajax, XML-RPC, and 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. requests. To log errors instead of displaying them, or to keep the previous behavior, define the constants explicitly:
// Keep debugging on but log instead of display.
define( 'WP_DEBUG', true );
define( 'WP_DEBUG_DISPLAY', false );
define( 'WP_DEBUG_LOG', true );
// Or restore the pre-7.2 default.
define( 'WP_DEBUG', false );
For more information, refer to #66243 and r64115.
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 and Metadata
New register_site_meta() and unregister_site_meta() functions
Site 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. (the blog meta type, stored in the blogmeta table) can now be registered with a wrapper function, as post, term, comment, and user meta already could:
register_site_meta( string $meta_key, array $args ): boolcallsregister_meta( 'blog', $meta_key, $args ).unregister_site_meta( string $meta_key ): boolcallsunregister_meta_key( 'blog', $meta_key ).
get_object_subtype() now supports the blog object type. For an existing site on a multisite install it returns 'blog'. For an 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. site ID, or on a single-site install, it returns an empty string. Site meta registered with 'object_subtype' => 'blog' is therefore resolved by get_registered_metadata(), sanitize_meta(), and the registered default value handling. Before 7.2, only site meta registered without an object subtype took effect. Callbacks on the get_object_subtype_blog filter now receive 'blog' instead of an empty string for existing sites.
Both functions are defined in wp-includes/ms-site.php, which is loaded only on multisite, in the same way as add_site_meta() and the other site meta functions. Code shared with single-site installs should check is_multisite() first. Site meta also requires the blogmeta table; is_site_meta_supported() reports whether it exists.
add_action(
'init',
static function () {
if ( ! is_multisite() ) {
return;
}
register_site_meta(
'my_plugin_site_tier',
array(
'type' => 'string',
'single' => true,
'default' => 'standard',
'sanitize_callback' => 'sanitize_key',
)
);
}
);
// Later:
$tier = get_site_meta( $site_id, 'my_plugin_site_tier', true );
As with register_term_meta() and register_post_meta(), register_site_meta() registers the key for the whole object type unless object_subtype is passed in $args. WordPress core does not include a REST API endpoint for sites, so the show_in_rest argument has no effect in core.
For more information, refer to #44387 and r63603.
Administration
“Howdy” moves from the toolbar into the user menu
To free up space in the toolbar, the top-level my-account item now shows only the user’s display name and 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.. The “Howdy, %s” greeting now appears in the user-info item inside the user menu.
Top-level my-account node title, before and after:
<!-- WordPress 7.1 -->
Howdy, <span class="display-name">Jane Doe</span><img ... />
<!-- WordPress 7.2 -->
<span class="display-name user-display-name">Jane Doe</span><img ... />
user-info node title, before and after:
<!-- WordPress 7.1 -->
<img ... /><span class='display-name'>Jane Doe</span><span class='username'>jane</span><span class='display-name edit-profile'>Edit Profile</span>
<!-- WordPress 7.2 -->
<img ... /><span class='display-name howdy'>Howdy, <span class='user-display-name'>Jane Doe</span></span><span class='username'>jane</span><span class='display-name edit-profile'>Edit Profile</span>
Other changes:
- When a user’s display name is empty, both items fall back to the user login.
- The
menu_titlemeta value of themy-accountnode, used as the accessible name of the user menu, is now the display name without the greeting. - The
.usernamespan is now always output. It has thehiddenattribute when the display name and the user login are the same, so it can be shown or hidden while the display name is edited on the profile screen. - The new
user-display-nameclass marks every element that contains the display name. The profile screen uses it to update the toolbar when the “Display name publicly as” field changes. - The greeting wrapper keeps the
display-nameclass, so adminadmin (and super admin) color schemes that style#wp-admin-bar-user-info .display-namecontinue to apply.
Compatibility considerations:
- The
Howdy, %sstring and its translator comment are unchanged. Plugins that change the greeting through thegettextfilter will now change the text in the user menu, not the top-level toolbar item. - Code that edits the
my-accountnode title, for example withstr_replace()on “Howdy”, will no longer find the greeting there. Such code can target theuser-infonode instead, or set themy-accounttitle after core adds it. Core adds that node at priority9991ofadmin_bar_menu:
add_action(
'admin_bar_menu',
static function ( WP_Admin_Bar $wp_admin_bar ) {
$node = $wp_admin_bar->get_node( 'my-account' );
if ( ! $node ) {
return;
}
$wp_admin_bar->add_node(
array(
'id' => 'my-account',
'title' => esc_html__( 'Signed in as', 'my-plugin' ) . ' ' . $node->title,
)
);
},
9992
);
- Stylesheets that change the
displayvalue of#wp-admin-bar-user-info .usernameshould make sure.username[hidden]stays hidden. Core includes adisplay: nonerule for it.
For more information, refer to #66157, r64312, #66222, and r64519.
Add Theme restored to the Appearance menu
On single-site installs, Appearance > Add Theme is a submenu item again, linking to theme-install.php. It requires the install_themes 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). and has the hide-if-no-js class. The theme installer and the theme upload screen now set $submenu_file to theme-install.php, so Add Theme is highlighted on those screens instead of Themes. The Networknetwork (versus site, blog) Admin Themes menu is unchanged.
The new item takes position 6 in $submenu['themes.php'], and the core items after it move down by one:
| Item | 7.1 key | 7.2 key |
|---|---|---|
| Themes | 5 | 5 |
| Add Theme | n/a | 6 |
| Editor / Design / Patterns | 6 | 7 |
| Customize | 7 | 8 |
| Widgets (classic themes) | 8 | 9 |
| Fonts | 9 | 10 |
| Menus | 10 | 11 |
| 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. / Background | 15 / 20 | 15 / 20 (unchanged) |
Code that reads, replaces, or unsets $submenu['themes.php'] entries by numeric key may now affect a different item. Removing or finding items by slug is not affected by position changes:
add_action(
'admin_menu',
static function () {
// Remove the Add Theme item.
remove_submenu_page( 'themes.php', 'theme-install.php' );
},
999
);
Plugins that add a submenu item at a fixed position in Appearance may want to check its placement.
For more information, refer to #47124 and r64352.
New .delete-link CSSCSS Cascading Style Sheets. class
A new .delete-link class is available for links that perform a destructive action. It uses the same colors as .button-link-delete in each admin color scheme, including the darker color on hover and focus. Unlike .button-link-delete, it does not need to be combined with .button-link, so it can be added to a plain <a> element. The rules are scoped to .wp-core-ui.
<a href="<?php echo esc_url( $delete_url ); ?>" class="delete-link"><?php esc_html_e( 'Delete', 'my-plugin' ); ?></a>
The class is defined in the admin color scheme stylesheets. The Fresh color scheme does not load a color scheme stylesheet, so the class has no effect when Fresh is selected.
For more information, refer to #36882 and r64603.
Script Loader
Obsolete script compression constants and compression test removed
load-scripts.php and load-styles.php have not compressed their output since WordPress 4.9.9 (r43580). The code that configured and tested that compression was still present. WordPress 7.2 removes it:
- The
COMPRESS_SCRIPTS,COMPRESS_CSS, andENFORCE_GZIPconstants are no longer read or documented. Defining them has no effect.COMPRESS_SCRIPTSandCOMPRESS_CSSare also no longer listed on the Site Health Info tab (r64321). - The
$compress_scriptsand$compress_cssglobals are kept for code that reads them, but now default tofalse. A value already set by a pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. is left unchanged. compression_test()andwp_ajax_wp_compression_test()are deprecated and do nothing. The compression test no longer runs in the admin footer.- The
wp-compression-testAjax action is no longer registered. - The
can_compress_scriptsoption is no longer set or primed. Single sites already delete it on a database upgrade, as it is in the list of unused options. On multisite, where it is a network option,upgrade_network()now deletes it.
Code that defines the constants can remove them. Code that calls compression_test() will trigger a deprecation notice when WP_DEBUG is enabled.
These changes are part of the wider retirement of script and style concatenation in WordPress 7.2 (#57548, r64585). With that change, script_concat_settings(), which sets the globals above, is itself deprecated.
For more information, refer to #63017, r64485, and r64486.
Upgrade/Install
A .git file is now detected as a version-control checkout
WP_Automatic_Updater::is_vcs_checkout() decides whether automatic updates are skipped because a site is under version controlversion control A version control system keeps track of the source code and revisions to the source code. WordPress uses Subversion (SVN) for version control, with Git mirrors for most repositories.. It previously checked for a .git directory with is_dir(). In a 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/ worktree or submodule, .git is a plain file that points to the repository, so such sites were treated as not under version control, and automatic updates ran.
is_vcs_checkout() and the Site Health check WP_Site_Health_Auto_Updates::test_vcs_abspath() now use file_exists(). A .svn, .git, .hg, or .bzr entry of either type, in the checked directory or any directory above it, marks the site as a checkout. The contents of a .git file are not read.
Sites that run from a Git worktree or submodule will therefore no longer receive automatic core, plugin, theme, or translationtranslation The process (or result) of changing text, words, and display formatting to support another language. Also see localization, internationalization. updates. Site Health and the update screens report the reason. The automatic_updates_is_vcs_checkout filter still decides the final result:
add_filter( 'automatic_updates_is_vcs_checkout', '__return_false' );
For more information, refer to #66460 and r65259.
Props to @audrasjb for peer review.
Abilities API updates in WordPress 7.2
WordPress 7.2 updates the Abilities 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. to make permissions, input handling, and 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. output more predictable. Abilities can declare 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). required for every call. Direct PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher calls and REST requests sanitize input according to the ability’s schema, and JSON results preserve the object or array shape that the schema declares. The examples below show what ability authors and integration developers need to change.
Declare required capabilities
The new required_capabilities registration argument accepts a list of non-empty 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). strings. During permission checking, WordPress checks each capability with current_user_can(). All listed capabilities must pass before the permission callback runs.
Use this list for requirements that apply to every invocation. For example, core/settings-get always requires manage_options. Its registration declares that capability and omits permission_callback. This excerptExcerpt An excerpt is the description of the blog post or page that will by default show on the blog archive page, in search results (SERPs), and on social media. With an SEO plugin, the excerpt may also be in that plugin’s metabox. shows its permission arguments:
array(
'required_capabilities' => array( 'manage_options' ),
// No permission_callback: the capability covers every call.
);
When permissions also depend on the input, keep that check in permission_callback. The following ability requires edit_posts for every call, then checks whether the user can edit the requested post. The example assumes that the my-plugin categoryCategory The ‘category’ taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging. is already registered:
add_action(
'wp_abilities_api_init',
static function () {
wp_register_ability(
'my-plugin/get-post-title',
array(
'label' => __( 'Get post title', 'my-plugin' ),
'description' => __( 'Read the title of a post you can edit.', 'my-plugin' ),
'category' => 'my-plugin',
'required_capabilities' => array( 'edit_posts' ),
'input_schema' => array(
'type' => 'integer',
'minimum' => 1,
),
'output_schema' => array( 'type' => 'string' ),
'permission_callback' => static function ( int $post_id ): bool {
return current_user_can( 'edit_post', $post_id );
},
'execute_callback' => static function ( int $post_id ): string {
return get_post_field( 'post_title', $post_id, 'raw' );
},
'meta' => array(
'show_in_rest' => true,
'annotations' => array( 'readonly' => true ),
),
)
);
}
);
Choose the permission arguments according to the ability’s requirements:
- If a non-empty
required_capabilitieslist covers every permission check, omitpermission_callback. You do not need__return_true. - If a call needs additional checks, such as access to a particular post, provide a callback. The declared capabilities are checked first.
- If
required_capabilitiesis empty or omitted, a validpermission_callbackis required. Use__return_trueonly when the ability is intentionally executable by everyone; otherwise, provide the appropriate permission check.
The existing wp_ability_permission_result 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. still receives the result and can override it, including a denial caused by a missing capability.
Filter discovery by capabilities
Integrations can read the declaration with $ability->get_required_capabilities(). It is also included in REST discovery responses.
To request abilities whose declared requirements the current user meets:
$abilities = wp_get_abilities(
array( 'has_required_capabilities' => true )
);
The REST collection supports the same opt-in filter:
GET /wp-json/wp-abilities/v1/abilities?has_required_capabilities=true
This filter does not run permission callbacks or the wp_ability_permission_result filter. Abilities without declared capabilities pass this filter (other discovery filters can still exclude them), and an ability that passes discovery can still deny execution for a particular input. In the example above, an author may discover the ability while lacking permission to read another author’s draft through it.
Declare only the capabilities needed for every invocation. Putting an input-specific requirement in the static list can hide an ability from users who are allowed to execute it with other inputs.
Related ticketticket Created for both bug reports and feature development on the bug tracker.: #66325.
Prepare input consistently across execution paths
WP_Ability::prepare_input() now handles the input preparation used by execute():
- Normalize the input, including applying a top-level schema default when the input is
null. - Validate it against the input schema.
- Sanitize the validated value using the schema.
The permission and execute callbacks receive the prepared value. For the example above, $ability->execute( '123' ) passes the integer 123 to both callbacks. Schema formats also matter: a string declared with format: text-field has its tags stripped during sanitization.
Validation runs before sanitization. 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. values are rejected before casting or property removal can hide the error. A failure during preparation returns a WP_Error and stops execution.
The REST execution controller prepares the original request input independently for its permission check and for execution. Custom integrations that call execute() can pass the raw input and let the ability prepare it.
Number inputs become floats
A number schema converts an integer such as 10 to the float 10.0 in direct PHP calls, matching REST behavior. Use an integer schema when a callback needs integers. Callbacks using number should accept floats and avoid checks such as is_int( $input ) or $input === 10.
Other schema conversions include the string "false" becoming the boolean false, and "1,2" becoming array( 1, 2 ) for an array-of-integers schema.
Sanitization failures stop execution
Input can pass validation and still fail sanitization. For example, array( '1', '01' ) contains distinct strings, but both become the integer 1. That fails an array-of-integers schema with uniqueItems: true.
In 7.2, this failure returns ability_invalid_input, including when it occurs in a nested field, before permission or execute callbacks run. The REST endpoint returns 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. 400. It no longer falls back to the original unsanitized input when one field fails; such a fallback could otherwise leave a permission callback with the string "false", which is truthy in PHP.
Direct permission checks need prepared input
check_permissions() does not prepare its input. If an integration calls it directly, it must first call prepare_input() and stop on an error:
$ability = wp_get_ability( 'my-plugin/get-post-title' );
if ( null === $ability ) {
return new WP_Error( 'example_missing_ability', 'The ability is not registered.' );
}
$input = $ability->prepare_input( '123' );
if ( is_wp_error( $input ) ) {
return $input;
}
// $input is now the integer 123.
$permission = $ability->check_permissions( $input );
if ( is_wp_error( $permission ) ) {
return $permission;
}
if ( true !== $permission ) {
return new WP_Error( 'example_forbidden', 'You cannot edit this post.' );
}
// This checks permission only. To run the ability, use execute().
A direct permission check does not execute the ability. For execution, call execute(); it performs preparation and checks permissions as part of the normal lifecycle.
Calling normalize_input() alone is insufficient: it does not include schema validation and sanitization. Likewise, validate_input() returns a validation result, not a prepared value.
A custom permission-check path that already normalizes and validates input can replace those steps with prepare_input(). Keep the error check before calling check_permissions():
- $input = $ability->normalize_input( $raw_input );
+ $input = $ability->prepare_input( $raw_input );
if ( is_wp_error( $input ) ) {
return $input;
}
- $valid = $ability->validate_input( $input );
- if ( is_wp_error( $valid ) ) {
- return $valid;
- }
$permission = $ability->check_permissions( $input );
This adds schema sanitization to the custom path. Continue to handle the permission result as shown above.
The REST controller’s sanitize_input_for_ability() method is deprecated in 7.2 and is no longer registered as the input sanitizer. Its compatibility implementation returns the input unchanged.
Related ticket: #66383.
Preserve empty objects in JSON
An empty PHP array encodes as [], even when the schema describes an object. That can leave a client expecting an object with an array instead.
The shared wp_prepare_json_schema_for_client() function prepares schemas for use outside WordPress’s server-side validation. It removes unsupported keywords and prepares nested schemas and their existing defaults, so it is useful wherever a pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. exposes a schema to a REST client or frontend. In 7.2, its default-value handling preserves empty objects according to the schema:
$schema = array(
'type' => 'object',
'default' => array(),
);
echo wp_json_encode( wp_prepare_json_schema_for_client( $schema ) );
// {"type":"object","default":{}}
The new wp_prepare_json_value_for_client() function applies the same distinction to result values, including nested properties and array items:
$schema = array(
'type' => 'object',
'properties' => array(
'settings' => array( 'type' => 'object' ),
'items' => array(
'type' => 'array',
'items' => array( 'type' => 'object' ),
),
),
);
$result = array(
'settings' => array(),
'items' => array( array() ),
);
echo wp_json_encode( wp_prepare_json_value_for_client( $result, $schema ) );
// {"settings":{},"items":[{}]}
The Abilities 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/ applies these helpers when preparing schemas and execution results, including root empty objects and objects inside top-level lists. The WordPress AI Client also prepares ability results using the output schema. A direct PHP call to $ability->execute() still returns the callback’s result without this JSON representation step. Custom transports that serialize the result should prepare it with the ability’s output schema before encoding it.
This preparation does not perform full schema validation or fill in missing defaults. It changes the representation of existing values. An empty array stays [] when the matching schema permits an array; a schema that permits both objects and arrays does not force it to become {}.
Related ticket: #66267.
Updating an integration
Plugins supporting earlier WordPress versions must use version-appropriate registration arguments, retain their existing permission callbacks, and guard use of the new methods and functions. Omitting a permission callback in favor of required_capabilities requires WordPress 7.2.
Review callbacks that depend on the original PHP type or unsanitized input. Check custom permission-check paths for missing preparation, and apply JSON preparation at serialization boundaries when using a custom transport.
Ability authors should declare type: object or type: array explicitly in the output schema, including nested properties whose empty values matter. A client consuming an object schema should expect {} for an empty result. Update code that depended on receiving [] in that case. Results declared as arrays continue to use [].
For a custom transport, prepare a successful result immediately before JSON encoding. Here, $ability is an already resolved WP_Ability, and $raw_input is the caller’s input:
$result = $ability->execute( $raw_input );
if ( is_wp_error( $result ) ) {
return $result;
}
return wp_json_encode(
wp_prepare_json_value_for_client(
$result,
$ability->get_output_schema()
)
);
The helper preserves the schema’s JSON shape. It does not grant permission or replace execution. Keep errors on the transport’s normal error path instead of preparing them as successful results.
Please test these changes against your abilities and share any compatibility concerns on the related tickets.
Props to @euvoor for compiling the post, and to @jorgefilipecosta, @justlevine, @nikskyverge for verification.
Link to a file and line in WordPress Playground
Why does Hello Dolly show a lyric on the WordPress dashboard but hide it 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? With Playground’s new filebrowser query parameter, you can answer that question by sending someone straight to the line of code that explains it. This feature was designed for moments when you want to share feedback from a specific line, and the new 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. parameter filebrowser lets Playground users connect those dots.
Show the relevant line in a bug report
For exemple, if you want to create a link to installs Hello Dolly 1.7.2 and places the cursor on line 85 of hello.php. There you’ll find the CSSCSS CSS is an acronym for cascading style sheets. This is what controls the design or look and feel of a site. selector .block-editor-page #dolly. The next line sets display: none, which hides the lyric in the editor. Open Hello Dolly at line 85.
The filebrowser parameter selects the code.
filebrowser=wp-content/plugins/hello-dolly/hello.php:85
Use a path relative to the WordPress installation. The :85 suffix places the cursor on line 85. Line numbers start at 1. For a bug report, pin 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. version with plugin=hello-dolly.1.7.2.zip so the link keeps pointing to the same code after an update.

Start a theme workshop in the right file
For a lesson on color palettes, open Twenty Twenty-Five’s theme.json and ask participants to find settings.color.palette. The first two entries define the theme’s Base and Contrast colors. Leave off the line number when you want readers to explore the file. Open Twenty Twenty-Five’s color settings in Playground.

To let readers choose their own file, use Playground with just ?filebrowser. Share these examples as standalone links. Embedded iframes and mode=seamless skip the Files pane. Playground Query API reference. Those are some of the actions that you can do today with Playground. I would like to hear from you what you can build with the new filebrowser query API.
Go to the Playground channel and share your feedback with us.
AI Contributor Weekly Summary – 18 November 2026
This week’s meeting focused on improving collaboration and decision-making within the AI team, clarifying the role of WordPress coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. committers, and establishing development workflows for abilities targeted for WordPress 7.3. Contributors also reviewed progress on the shared WordPress Abilities package, discussed how to coordinate development between WordPress core and the package, and highlighted new testing infrastructure for validating abilities across AI providers.
Contributor Collaboration and Decision-Making
@jason_the_adams opened the meeting by emphasizing the importance of team cohesion, respectful disagreement, and following the WordPress Code of Conduct.
The discussion reinforced several principles for effective collaboration:
- Team cohesion: Contributors should prioritize empathy, kindness, and productive collaboration, even when technical disagreements arise.
- Core committer authority: WordPress core committers are trusted to make technical decisions without requiring unanimous consensus, while continuing to welcome community feedback.
- Disagree and commit: Contributors should feel comfortable raising concerns while respecting decisions and moving forward together.
- Decisive leadership: Core committers were encouraged to clearly communicate when discussions have reached a decision, helping the team maintain momentum.
@gziolo, @jorgefilipecosta, and @karmatosed were identified as the core committers participating in the team. Contributors also clarified that additional committer approval is required during the Release CandidateRelease Candidate A beta version of software with the potential to be a final product, which is ready to release unless significant bugs emerge. phase, while earlier development allows greater flexibility.
WordPress 7.3 Abilities Development
@jorgefilipecosta introduced a proposed minimum set of abilities for WordPress 7.3, including their input and output schemas, and requested contributor feedback before implementation progresses further.
The team aligned on a development workflow that establishes WordPress core as the source of truth for abilities targeted for 7.3:
- Core-first development: Abilities planned for WordPress 7.3 will be developed and reviewed directly in WordPress core.
- Package synchronization: Once merged into core, abilities will be synchronized into the shared WordPress Abilities package for distribution to projects such as the MCP AdapterMCP Adapter Translates WordPress abilities into Model Context Protocol format, allowing AI assistants like Claude and ChatGPT to discover and invoke WordPress capabilities as tools, resources, and prompts..
- Experimental abilities: Additional abilities not yet targeted for core can be developed and tested directly within the package.
- Consistent implementations: Abilities shared between core and the package should use matching implementations to ensure testing and feedback apply to the code ultimately shipped in WordPress.
This approach aims to reduce duplicated development and the synchronization challenges previously encountered when moving functionality from the AI pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. into WordPress core. Contributors acknowledged that exceptions may be appropriate when earlier package testing is needed, while maintaining core-first development as the default for WordPress 7.3 functionality.
Shared Abilities Package and Contributor Workflows
@nikskyverge shared progress on organizing the new abilities repository, including cleanup tasks and outstanding discussions around naming conventions, visibility defaults, and other implementation standards. The team discussed improving visibility into which abilities are planned for WordPress 7.3, which remain experimental, and where contributors can participate in development and review.
Several improvements were identified:
- Maintaining a central list of planned abilities and their development status in the repository README.
- Linking WordPress core tickets and pull requests to the corresponding abilities tracking issues.
- Exploring GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged by the repository owner. https://github.com/ project boards, labels, and other tools to make active work and review opportunities easier to discover.
- Keeping the package synchronized with core changes, ideally shortly after they are committed.
Contributors also emphasized that experimental abilities distributed through the package must receive appropriate review, particularly given their potential adoption through projects such as the MCP Adapter.
Abilities Testing Infrastructure
@jorgefilipecosta shared work on new testing infrastructure for validating abilities against three major AI providers. The proposed tests will help verify that registered abilities can be consumed correctly by AI providers, including Gemini and Anthropic, and identify compatibility issues earlier in development. To avoid unnecessary 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. costs, providerProvider An AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI).-specific tests will run only when the appropriate API keys are available rather than automatically consuming credits during continuous integration.
Next Steps
- Abilities schemas: Contributors are encouraged to review the proposed minimum set of WordPress 7.3 abilities, focusing on consistency and usability of input and output schemas. Suggestions and pull requests for improvements are welcome.
- Core development: @jorgefilipecosta and @gziolo will continue advancing abilities through WordPress core, with corresponding package synchronization.
- Repository organization: @nikskyverge will refine the abilities repository issue list and improve documentation of planned abilities and their development status.
- Contributor visibility: Continue linking core tickets, pull requests, and package work to the central abilities tracking efforts, making it easier for contributors to identify opportunities for feedback.
- Provider testing: Continue developing and reviewing the proposed AI provider testing infrastructure to catch compatibility issues earlier.
Upcoming Meetings
- Contributors are welcome to join the weekly AI contributor call. All team meeting schedules are published on the WordPress Meeting Calendar.
- AI Team Office Hours: Thursday, November 26, 2026 at 17:00 UTC.
Props to @gajendrasingh for pre-publish review.
Office Hours Meeting Recap, 28 October 2026
- Date: 28 October 2026
- Time: 15:00 UTC (local time)
- Platform: Zoom
- Issue: #3730
- Moderator: Sumit (@sumitsingh)
- Note-taker: Andrew (@andrewssanya)
- Note Review By: Rico F. Lüthi (@rfluethi), Sumit Singh (@sumitsingh), Vasantsinh Rajput (@vasantrajput)
Related links:
- Office Hours Meeting – Agenda for 28 October, 2026
- Previous recap: Office Hours Meeting Recap, September 26, 2026
- Previous recap: Office Hours Meeting Recap, August 22, 2026
- Previous recap: Office Hours Meeting Recap, 26th July 2026
- Sinhala Beginner WordPress User course issue (#3656)
Nine contributors joined this session. In this recap, Decisions are items the group agreed on in the meeting. Recommendations are proposals that still need the team’s confirmation. Please share feedback on the Recommendations as a comment on this issue or in the #training Slack channel.
Participants
| Name | 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/ Profile | Location |
|---|---|---|
| Sumit Singh | @sumitsingh | Ahmedabad, India |
| Rade Jekić | @rjekic | Serbia |
| Rico | @rfluethi | Switzerland |
| Nitesh Patel | @nitspatel | Ahmedabad, India |
| Vasantsinh Rajput | @vasantrajput | Ahmedabad, India |
| Pravin Karmur | @pravin1996 | Ahmedabad, India |
| Upeka | @upekar99 | Sri Lanka; lives between Latvia and Italy |
| Mohammad Katerega | @mohkatz | Jinja, Uganda |
| Dilip Modhavadiya | @dilip2615 | Ahmedabad, India |
Context
The session was divided into two parts. The first part covered introductions and a review of the 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/ issue backlog. The second part was hands-on, focusing on fixing @upekar99‘s translation issue live and planning triage meetings.
@rjekic thanked @rfluethi and @vasantrajput for keeping the team running while the team reps were unavailable. He emphasised that the reps are “not leaders, same level as all of you.” He also explained that @devmuhib had WP Credits and Campus Connect obligations, that being available online from Serbia was difficult, and that Sumit had his own commitments.
@rjekic clarified that the team operates without specific leaders, with reps serving as a communication bridge to other teams. Decisions are made collectively, and nothing is set in stone.
Throughout both parts of the session, the main blocker was that most contributors could not change labels or project fields.
Topics
1. A backlog of 600+ issues, many outdated or AI-generated
- The Learn WordPress GitHub repository has more than 600 open issues. Many were opened by contributors using AI tools to identify errors, so some no longer reflect the current website. Many translation-related issues were also created in the same way.
- @sumitsingh and @vasantrajput shared the project board and walked the group through its labels: admin agenda, awaiting triage, issue type, priority, 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), content, and site improvement.
- The group decided to review the backlog in smaller groups, starting with issues that have no type assigned, as these are the quickest to review. Issues that are no longer relevant will be closed, while the remaining issues will be labelled.
- HelpScout tickets are also piling up. @rjekic is working through the tickets he can after being away for a month, and @vasantrajput can convert a ticket into a GitHub issue. Ownership of each group of issues has not yet been decided.
2. Label and project rights are the blocker
- @rjekic showed how a correctly filed feedback issue gets its labels automatically. A reviewer then removes the “awaiting triage” label, assigns the project (for example, Learn WP Content Feedback), and changes the status to “awaiting validation.” Each issue needs two validations before anyone can start working on it.
- @rjekic described validating an issue as the easiest way to make a first contribution, for example, for someone who has commented on an issue and wants to help.
- If someone enters the type of feedback incorrectly, such as including an extra space, the automation does not run. In such cases, labels and project fields have to be set manually.
- Labels are not required to validate an issue, but contributors often search for issues using labels (for example, “good first issue”). As a result, unlabeled issues are harder to find.
- @upekar99 and @vasantrajput could not change labels or project fields. @rjekic and @sumitsingh were unsure whether they could grant these permissions themselves. Therefore, the group decided to ask @devmuhib and @psykro to grant label permissions to @rfluethi and @vasantrajput before announcing the triage meeting. @rjekic will contact @devmuhib.
- Who else needs these permissions is still to be determined.
3. Translation courses: one issue per lesson, linked from one course issue
- @upekar99 could not create sub-issues for the Sinhala Beginner WordPress User course. @rjekic explained that each lesson should have its own issue, while one main course issue should list all the individual lesson issues as links. GitHub then automatically converts them into sub-issues.
- He used the Bengali course issue (created by @devmuhib) as an example and pointed out that there must be no space between
#and the issue number. - During the call, he updated @upekar99‘s issue #3656 to “content translation,” assigned it to the Localisation Translation Progress project, and added Sinhala as the language.
- @upekar99 has translated lesson 1 in a Google Doc and will create the individual lesson issues. @sumitsingh will link them to the main course issue and remove the “awaiting triage” label.
- @rjekic also demonstrated how a completed translation moves to the next stage. It is added to the Learn WP Content Localisation project with the status set to “ready for review” and the language specified (Bengali in his example).
- He suspected that the Bengali translation was AI-generated because the issue had been opened just a week earlier. He also mentioned that each translation needs two reviewers who follow the relevant local glossaries, such as the German and Dutch glossaries.
4. Triage on Zoom first, then on 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/
- @rfluethi asked whether a session like this would be considered a triage meeting. @rjekic and @sumitsingh confirmed that it would. The group preferred using Zoom for the first few sessions so contributors could understand how triage works before moving to Slack once everyone is familiar with the process.
- @rjekic prefers weekend sessions and offered to share his screen to explain the purpose of triage. He noted that triage previously focused mainly on pull requests and code, but the team now needs it for day-to-day issue management.
- The group decided to hold the first triage meeting on a Saturday at 15:00 UTC, followed by weekly meetings at the same time. The announcement will be posted in the #training Slack channel once the label permissions are sorted out. Both @rfluethi and @sumitsingh offered to post the announcement. However, the date of the first Saturday is still to be confirmed.
- Triage involves sorting issues into appropriate categories and labels and deciding which issues can be fixed without validation and which require validation.
- After the first session, triage will become a recurring activity. However, the platform for future sessions (Slack, Google Meet, or Zoom) is still to be decided.
- @rjekic suggested treating triage as one larger project, alongside the project group meetings proposed by @psykro and @mosescursor. He will also ask @psykro, or anyone else with the necessary access, to grant triage permissions to the contributors.
5. Outdated lesson content has to change in every language.
- @rjekic is reviewing the Beginner WordPress User course. The first planned change is to replace Playground 5.1 with the latest version. Any changes made to the English lessons must also be communicated to all language teams; otherwise, the translations may become outdated or inconsistent with the original content.
- Many images also need to be replaced, and this process is not automated. If the changes are extensive, @rjekic will create a separate validation issue. However, responsibility for replacing the images has not yet been decided.
6. Next Office Hours and who takes notes
- The next Office Hours session will be held on a weekday at the same time. @sumitsingh suggested scheduling it on the last Wednesday of every month at a fixed time so it can be added to the team calendar.
- The moderator and note-taker for the next session have not yet been decided. Participants also noted that while an AI-generated summary of the recording is helpful, it still takes time to turn it into a proper meeting recap post.
Decisions
| # | Decision |
|---|---|
| 1 | Hold the first triage Zoom on a Saturday at 15:00 UTC, then weekly at the same time. |
| 2 | Ask Muhibul Haque and Jonathan to give label rights to Rico and Vasantsinh before the triage meeting is announced. |
| 3 | Start the backlog review with issues that have no type. |
| 4 | Each lesson gets its own issue; one aggregate issue per course links them. |
| 5 | The next Office Hours is on Wednesday, 25 November, at 15:00 UTC |
Rationale: label rights come first because triage means sorting issues into categories and labeling them. A weekday suits most people for monthly Office Hours, and Zoom helps people learn triage by watching it.
Recommendations (for the team to confirm)
| # | Recommendation | Consensus of attendees |
|---|---|---|
| 1 | Use the last Wednesday of each month as the standing Office Hours slot | Yes, as a proposal |
| 2 | Use two reviewers for each AI-generated translation, following local glossaries such as the German and Dutch ones. | To confirm |
| 3 | Give label and project rights to more contributors than just Rico and Vasantsinh, so triage does not depend on a few people. | To confirm |
Action Items
| Issue | Task | Responsible/ Participant | Status |
|---|---|---|---|
| — | Ask @devmuhib and @psykro to grant label/triage rights to @rfluethi, @vasantrajput, and others who need them. | @rjekic, @sumitsingh | Open |
| — | Announce the first triage Zoom in the training Slack channel. | @rfluethi / @sumitsingh | Open |
| — | Run the first triage session (share screen, explain triage and labels). | @rjekic | Open |
| #3656 | Create one issue per lesson for the Sinhala Beginner WordPress User course, starting with lesson 1. | @upekar99 | Open |
| #3656 | Connect the lesson issues into the aggregate course issue; remove “awaiting triage.” | @sumitsingh | Open |
| — | Replace Playground 5.1 with the newest version in the English lessons; tell all language teams. | @rjekic | Open |
| — | Replace outdated images in lessons. | @rjekic, @vasantrajput, language teams | Open |
| — | Validate feedback issues (two validations each). | All contributors | Open |
| — | Review AI-generated translations (two reviewers, follow local glossaries). | Language reviewers | Open |
| — | Clear HelpScout tickets and create GitHub issues where needed. | @rjekic, @vasantrajput | Open |
| — | Add the next Office Hours to the training team calendar. | @sumitsingh | Open |
| — | Create and publish the meeting notes. | @andrewssanya | Done |
| Issue | Task | Responsible/ Participant | Status |
Next meeting
This Office Hours session has been scheduled on a weekday as a trial. The day and time were finalised through proposals and discussions in the #training channel.
- Date: November 25, 2026
- Time: 15:00 UTC
- Issue: To be created
- Moderator: TBD
- Note-taker: TBD
Focus topic: To be decided. The moderator will announce it in the #training Slack channel.
Summary: Focus Topics
The team’s focus for the next few weeks is getting triage working so the backlog can be cleaned up.
- Access first: @rjekic will ask @devmuhib to give label and project rights to @rfluethi and @vasantrajput. The triage sessions are waiting for this.
- Triage sessions: The first Zoom is on a Saturday at 15:00 UTC, then weekly. It will be announced in #training once rights are set.
- Backlog clean-up: More than 600 open issues, starting with issues that have no type. Close what no longer applies and label the rest.
- Translations: One issue per lesson, linked from one course issue. @upekar99 creates the Sinhala lesson issues, and @sumitsingh links them. AI-generated translations get two reviewers.
- Outdated content: @rjekic updates Playground in the English lessons first, then every language team follows. Images need replacing too.
- Next Office Hours: Wednesday 25 November, 15:00 UTC. The moderator, note-taker and topics are still to be chosen.
Test Team Chat Agenda: 19th November, 2026
Here is the agenda for the upcoming Test Team Voice Chat scheduled for Thursday, 19 November at 18:00 GMT+3, which will be held in the #core-test Slack channel. Lurkers welcome!
Agenda
- Attendance
- Attendance check-in with the wp.org username
- Note-taker and facilitator selection for the next meeting
We encourage all members to contribute to the team chat, and we now welcome note-takers and Facilitators. This is a great time to get involved in the coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. test team. Have you recently joined, and you don’t know where to go? Start here (No Skills Required)- This week’s facilitator and note-taker is – @r1k0
- We are looking for a volunteer facilitator and note-taker for the next session. PingPing The act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” us #core-test to volunteer
- Test Team Discussions
- Discuss Proposal: “WordPress Development and Testing Guidelines” and decide on a way forward.
- Share your thoughts on: Fix broken tag and glossary links and outdated make/flow references in documenting-flow.md.
- Discuss Add GitHub Actions CI for Markdown Linting and Manifest Integrity.
- Decide on this minor fix direction: Add missing navigation links to new guides in get-setup-for-testing/index.md
- Open Floor
- Got a topic? Add in comments below, or bring it up live during the chat.
- WordPress Ecosystem Announcements
- WordPress 7.1.5 Release
- What’s new in Gutenberg 24.4? (12 November)
- Introducing Mētis, Our New Flagship Theme
- A new 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. to copy your site in Copy Your WordPress Site with Reprint
- WordPress notifications and declared intent: proposal for the path forward
- API for style state-aware block styling controls
- WordPress Contributor Toolkit 2.0: A redesigned app, in your language
- What’s new in AI 1.5.0 (29 OCTOBER 2026)?
- Presence API: What’s new
- Real-time Collaboration: A Guide to Sync Engines
- Call for feedback: the W and the site name in the Toolbar
- The MCP Adapter Plugin is Now Available on WordPress.Org
- Roadmap to 7.2
- Introducing Ipsum, the new default theme
- Test Team Announcements
- Call for Testing
- WordPress 7.2 Release Candidate 1 is ready for testing
- Call for testing: Xdebug in the WordPress Contributor Toolkit 2.1.0 beta
- Testing your hosting platform for WordPress 7.2 by November 17: the Secrets API, upgrades and /random/
- Call for Testing: Presence API
- Call for testing: DataForm editor inspector
- We have Patch Testing issues for the WordPress 7.2 milestone that need testing.
- We also have a couple of Gutenberg Issues that need testing.
Leave a Comment
- Do you have something to propose for the agenda?
- Can’t make the meeting, but have a question for the Test Team?
If any of the above apply, please leave a comment below.

Vasantsinh Rajput
Thank you, Andrew (@andrewssanya) for the Office Hours recap; it’s well summarised!
Reply