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.
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.
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 {}.
What integration developers should change
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.
Related ticket: #66267.
Updating an integration
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.
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.
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 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.
Reorganizing Trac Notifications in Slack
For as long as the WordPress project has used 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/, wordpress.org has fed notifications for every new ticketticket Created for both bug reports and feature development on the bug tracker. from TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. and every commit to develop.svn.wordpress.org into the #core channel to keep contributors aware of contributor activity. This practice also extends to the individual component channels (for example, #core-media) using the Component ticket field and a list of relevant file paths, and some channels even subscribe to activity on relevant 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/ repositories.
This has worked well for over a decade. But recently it’s become clear that the volume of activity is untenable. Channels meant for discussions now function as pseudo-firehose channels. Important discussions become difficult to find and easy to miss entirely, and many contributors have expressed that they are unable to keep up or follow along.
Given this, it’s time to rethink how Trac & GitHub notifications are posted in Slack.
What has changed?
As of r15625-meta, the following changes have been made to Trac notifications in Slack:
- Individual
#core-{component}channels no longer receive commit notifications. These are now fed into#core-{component}-commits. - Individual
#core-{component}channels no longer receive new ticket notifications. These are now fed into#core-{component}-newtickets. - New
#core-{component}-firehosechannels have been created and serve as a true firehose for all activity directly belonging to the component (new tickets, commits, and all comments on tickets withComponentset to the matching value). - Commit notifications in
#coreremain, but now only show the first line (short description) of each commit message. - New ticket notifications in
#coreare unchanged. - New #core-gutenberg-firehose, #core-gutenberg-commits, and #core-gutenberg-newtickets channels have been created and are subscribed to the corresponding activity from the WordPress/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/ repository on GitHub.
- With the new
#core-gutenberg-*channels,#corehas been unsubscribed fromWordPress/gutenbergcommit notifications. - #core-editor-commits has also been unsubscribed from
WordPress/gutenbergcommit notifications and will now only show Editor component commits fromdevelop.svn.wordpress.org. Join the#core-gutenberg-commitschannel for the activity previously found here. - The behavior for individual focuses that do not overlap with a component (for example,
rest-apifocus andREST APIcomponent) is unchanged:coding-standardscontinues posting to #core-coding-standardscsscontinues posting to #core-cssjavascriptcontinues posting to #core-jsperformancecontinues posting to #core-performance
- Focuses that double as components continue to post new ticket notifications to the main channels (
multisite,privacy, andrest-api), but commits now only appear in the new-commitsand-firehosechannels.
The goal of these changes is to create targeted feeds that give contributors more control, allowing someone to follow or subscribe only to the specific activity streams that are relevant to them without drowning out discussion-based activity.
Were these channels created for every component?
Yes. -firehose, -newtickets, and -commits channels were created for every component, including those where the main channel had never existed. Main #core-{component} channels that didn’t already exist were not created. These channels were also created for components with an archived #core-{component} channel, which was left as archived.
What about subcomponents?
The notifications for each subcomponent have been configured to flow into the three channels belonging to the parent component, unless the subcomponent has its own channel. For example, the Notes subcomponent has #core-notes, so #core-notes-newtickets, #core-notes-commits, and #core-notes-firehose have been created.
What about other #core-name channels that do not map to a component?
Channels such as #core-test and #docs are not a part of this effort; only channels that explicitly belong to a component have been updated. More channels can be updated to follow the same pattern in the future wherever it makes sense. If a non-component-mapped channel has a need for a -newtickets, -commits, and -firehose channel, then please comment below for further assistance.
What about GitHub Activity?
These new channels are meant to only contain Trac/SVNSVN Subversion, the popular version control system (VCS) by the Apache project, used by WordPress to manage changes to its codebase. activity. As noted above, #core has been unsubscribed from the WordPress/gutenberg commit notifications because commits from that repository were drowning out important discussions.
Should component maintainers decide that a GitHub repository’s activity is important for their contributor group to follow, new notification channels can be considered. If a component you maintain would benefit from this, please comment below with the changes needed.
What about the pre-existing firehose channels?
The #core-firehose, #core-newtickets, #core-commits, #core-ci-firehose, and all non-CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. firehose channels (e.g. #meta-firehose, #glotpress-firehose, etc.) have not been modified and will continue to function as they always have.
Why does #core-gutenberg-newtickets show open and close activity for issues?
The GitHub Slack integration does not currently support filtering issues notifications by action (opening or closing), so the channel has been subscribed to both for now. This could be set up using GitHub Actions, but that can be a follow up item if necessary.
AI is a Trac component. Why does #core-ai-firehose contain GitHub Activity?
Currently, a large amount of the AI-related work merged into Core is built out in several different repositories maintained on GitHub. The pre-existing subscriptions in this channel have been left as is for the time being.
Can I follow several components at once?
Yes! Because these are Slack channels, you are able to follow as many as you’d like. You can even follow new tickets for one component and commits for another.
Feedback
As always, none of these changes are permanent and adjustments can be made based on community feedback. Please share any you may have below!
A full list of channels created as a part of this change can be found in the collapsed details 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. below.
All Created Channels
- #core-administration-commits
- #core-administration-firehose
- #core-administration-newtickets
- #core-ai-commits
- #core-ai-newtickets
- #core-bootstrap-commits
- #core-bootstrap-firehose
- #core-bootstrap-newtickets
- #core-build-test-tools-commits
- #core-build-test-tools-firehose
- #core-build-test-tools-newtickets
- #core-cache-api-commits
- #core-cache-api-firehose
- #core-cache-api-newtickets
- #core-comments-commits
- #core-comments-firehose
- #core-comments-newtickets
- #core-cron-api-commits
- #core-cron-api-firehose
- #core-cron-api-newtickets
- #core-customize-commits
- #core-customize-firehose
- #core-customize-newtickets
- #core-database-commits
- #core-database-firehose
- #core-database-newtickets
- #core-datetime-commits
- #core-datetime-firehose
- #core-datetime-newtickets
- #core-editor-newtickets
- #core-export-commits
- #core-export-firehose
- #core-export-newtickets
- #core-external-libraries-commits
- #core-external-libraries-firehose
- #core-external-libraries-newtickets
- #core-feeds-commits
- #core-feeds-firehose
- #core-feeds-newtickets
- #core-filesystem-api-commits
- #core-filesystem-api-firehose
- #core-filesystem-api-newtickets
- #core-formatting-commits
- #core-formatting-firehose
- #core-formatting-newtickets
- #core-general-commits
- #core-general-firehose
- #core-general-newtickets
- #core-gutenberg-commits
- #core-gutenberg-firehose
- #core-gutenberg-newtickets
- #core-help-about-commits
- #core-help-about-firehose
- #core-help-about-newtickets
- #core-html-api-commits
- #core-html-api-firehose
- #core-html-api-newtickets
- #core-http-api-commits
- #core-http-api-firehose
- #core-http-api-newtickets
- #core-i18n-commits
- #core-i18n-firehose
- #core-i18n-newtickets
- #core-importers-commits
- #core-importers-firehose
- #core-importers-newtickets
- #core-interactivity-api-commits
- #core-interactivity-api-firehose
- #core-interactivity-api-newtickets
- #core-mail-commits
- #core-mail-firehose
- #core-mail-newtickets
- #core-media-commits
- #core-media-firehose
- #core-media-newtickets
- #core-multisite-commits
- #core-multisite-firehose
- #core-multisite-newtickets
- #core-notes-commits
- #core-notes-firehose
- #core-notes-newtickets
- #core-options-meta-apis-commits
- #core-options-meta-apis-firehose
- #core-options-meta-apis-newtickets
- #core-passwords-commits
- #core-passwords-firehose
- #core-passwords-newtickets
- #core-permalinks-commits
- #core-permalinks-firehose
- #core-permalinks-newtickets
- #core-plugins-commits
- #core-plugins-firehose
- #core-plugins-newtickets
- #core-posts-post-types-commits
- #core-posts-post-types-firehose
- #core-posts-post-types-newtickets
- #core-privacy-commits
- #core-privacy-firehose
- #core-privacy-newtickets
- #core-query-commits
- #core-query-firehose
- #core-query-newtickets
- #core-restapi-commits
- #core-restapi-firehose
- #core-restapi-newtickets
- #core-script-loader-commits
- #core-script-loader-firehose
- #core-script-loader-newtickets
- #core-security-commits
- #core-security-firehose
- #core-security-newtickets
- #core-site-health-commits
- #core-site-health-firehose
- #core-site-health-newtickets
- #core-sitemaps-commits
- #core-sitemaps-firehose
- #core-sitemaps-newtickets
- #core-taxonomy-commits
- #core-taxonomy-firehose
- #core-taxonomy-newtickets
- #core-themes-commits
- #core-themes-newtickets
- #core-toolbar-commits
- #core-toolbar-firehose
- #core-toolbar-newtickets
- #core-upgrade-install-commits
- #core-upgrade-install-firehose
- #core-upgrade-install-newtickets
- #core-users-commits
- #core-users-firehose
- #core-users-newtickets
- #core-xml-rpc-commits
- #core-xml-rpc-firehose
- #core-xml-rpc-newtickets
Props @jeffpaul, @jorbin, @westonruter for pre-publish review, and @obenland for help on the 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. side.
Proposal: An opt-in attendee list for sponsors at WordCamp Asia 2027
The 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 team would like to try something new: an opt-in attendee list as a sponsor benefit, so attendees can choose to connect with sponsors before and during the event. This is a one-event pilot. We will measure the results and update the handbook based on what we learn.
Today, the handbook says attendee data cannot be shared with sponsors, so we want to discuss this openly with the community first.
A good moment to try new things
The web is changing fast, and so are our events. Sponsors tell us they want real conversations with agency owners and decision makers. Many attendees also come to WordCamp to find clients, partners, jobs and tools.
Right now, we cannot help these people find each other. Most tech conferences already offer this. We believe we can offer it in our own way: open, transparent, and always the attendee’s choice.
What everyone gets
- Attendees: a chance to meet the sponsors they care about during the event, and to hear about tools, services, and business opportunities.
- Agencies and freelancers: a better chance to meet companies that want to work with the WordPress ecosystem.
- Sponsors: clear value and a reason to keep supporting WordCamps.
- The community: stronger sponsorship helps keep tickets affordable and supports scholarships and community programs.
- Other WordCamps: real data from one event, so future flagships and local WordCamps can decide what works for them.
Simple and attendee-first
- Attendees choose. One unticked checkbox, separate from the ticket. It is never a condition to attend.
- Before the event, once the sponsor list is final, attendees see the list of sponsors and choose to share only their name, email, and organization. Sponsors can then invite them to meet during the event.
- Only the top three sponsor tiers take part.
- Attendees can withdraw at any time.
How we protect attendees
Before any list is shared, each sponsor signs a data sharing agreement with us. @harmonyromo has offered to help us prepare this agreement.
- If an attendee replies and starts a conversation, the sponsor may keep that contact under its own privacy notice. All other data must be deleted within six months of the event.
- Sponsors cannot share the list, upload it to advertising platforms, or add people to newsletters or marketing sequences.
- Sponsors can use it only to contact attendees about their own products and services, as shown when attendees opt in.
- The agreement is designed to meet GDPR-level standards and applicable local laws.
- The WordPress.orgWordPress.org The community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/ privacy policy will say that sharing with sponsors is possible.
- We keep a record of the data processing and a real privacy contact address.
- Sponsors that break the data sharing agreement lose eligibility for future WordCamp sponsorship.
- Attendees can withdraw with one click, even after the list is shared. We will tell the sponsors, and they must delete the data within five business days.
Once data is sent, we cannot see how it is used or pull it back. We rely on the signed agreement and its consequences. If something goes wrong, we will act and tell the affected attendees.
How we will learn from it
We will look at:
- the opt-in rate
- withdrawals and complaints
- attendee feedback
- sponsor feedback and results
After the event, we’ll share the results here. If the pilot works, we’ll propose a handbook update.
Share your feedback
We would love your ideas:
- How can we make this valuable for both attendees and sponsors?
- What would make you comfortable to opt in?
- Have you seen this done well at other events?
Please share your thoughts in the comments. Let’s try something new together!
This idea comes from many people working together. A special thank you to @karenalma for shaping this plan, and to @harmonyromo for offering to help with the legal and privacy side. Thanks also to @adityakane and @malgra for their careful reviews and comments, to @unintended8 and @4thhubbard, and to my fellow WordCamp Asia 2027 leads @wpwebhost, @julians3, and @onealtr and our sponsor team for their ideas and support along the way.
I think this is a great initiative and an opportunity to create more value for both attendees and sponsors.
I particularly like that participation is entirely optional. I’d just suggest keeping the consent process transparent so attendees clearly understand which sponsors will receive their information, what will be shared, and how it will be used.
Could you combine this with a QR code on each user’s badge? Just a serial number, which approved sponsors can use to find the opted-in contact details of this person. I.e. If not opted-in, the API call/endpoint will just reply 404…
Love this idea. Helping attendees and sponsors find each other before the event could lead to some really valuable conversations. I appreciate that it’s opt-in and that you’ve put so much thought into how the information can be used. Fully supportive of giving this a try!
Miscellaneous Editor Changes in WordPress 7.2
In this post, you will find dev notesdev 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. for smaller changes to the editor in WordPress 7.2.
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
Removed __experimentalGroup prop from InspectorControls
WordPress 7.2 removes the __experimentalGroup prop from InspectorControls and InspectorControls.Slot. Use the group prop instead. (#83171)
The prop was stabilized as group in WordPress 6.2 (#47105). Since then, passing __experimentalGroup logged a deprecation warning that named WordPress 6.4 as the removal version. WordPress 7.2 completes that removal.
Code that still passes __experimentalGroup now renders its controls in the default group, with the block’s other settings. For example, controls meant for the Advanced panel now appear outside it. A ToolsPanelItem meant for a panel such as Typography renders without that panel around it.
To update, rename the prop. The group prop works in WordPress 6.2 and later, so no version check is needed:
// Before
<InspectorControls __experimentalGroup="advanced">
<TextControl label={ __( 'Custom ID' ) } value={ id } onChange={ setId } />
</InspectorControls>
// After
<InspectorControls group="advanced">
<TextControl label={ __( 'Custom ID' ) } value={ id } onChange={ setId } />
</InspectorControls>
For the Advanced panel, InspectorAdvancedControls is also available and sets group="advanced" for you.
References:
Deprecated __experimentalImageEditor component: stylesheet moved
The @wordpress/block-editor npm package and the wp.blockEditor global export an __experimentalImageEditor component for building image cropping and editing interfaces. The component was deprecated in WordPress 7.1, so avoid using it.
If your code still uses it, note a CSSCSS Cascading Style Sheets. change in WordPress 7.2. The component’s stylesheet was incorrectly defined in the @wordpress/block-library package. In 7.2 it moves to @wordpress/block-editor. Update any imports of the stylesheet to the new location.
References:
Additional CSS now applies to blocks rendered by a parent block
Starting in WordPress 7.2, Additional CSS (set in a block’s Advanced panel) works for blocks that a parent block renders itself, such as a Navigation Link inside a Navigation block.
Before, that CSS was missing on the front end. CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. generated it only for blocks in a parent’s regular inner content. The Navigation block loads its inner blocks from a navigation menuNavigation Menu A theme feature introduced with Version 3.0. WordPress includes an easy to use mechanism for giving various control options to get users to click from one place to another on a site. post, so those blocks skipped that step.
Now the CSS is generated when each block renders, however its parent loaded it. Blocks that already worked are unaffected, and their CSS is not duplicated.
No code changes are needed. Rules that were previously ignored will now apply, so check for any you don’t want.
References:
Mobile multi-selection and event handler compatibility
From WordPress 7.2, the Paragraph block supports native iOSiOS The operating system used on iPhones and iPads. and Android multi-selection. To achieve this, the block opts in to moving the contenteditable wrapper from the block to the canvas wrapper.
The consequence is that editing event handlers (key, input, and composition events) no longer fire on the block but on the canvas element. This only affects the Paragraph block for now, which has been adapted. It will also affect other text blocks in the future, such as Heading and List Item. It will not affect non-core blocks unless they opt in when the APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. becomes available.
It will, however, affect filters that add props to the Paragraph block. For example:
addFilter(
'editor.BlockListBlock',
'my-plugin/track-keys',
( BlockListBlock ) => ( props ) => (
<BlockListBlock
{ ...props }
wrapperProps={ {
...props.wrapperProps,
onKeyDown: ( event ) => {
// ...
},
} }
/>
)
);
Such cases are covered by calling the listeners with a pseudo-SyntheticEvent. Any handler added this way should still be called, but there might be very subtle changes, such as the native event target pointing to the canvas rather than the block element. The target of the synthetic event has been adjusted to be the block.
References:
- Add an
editableRootblock support for native cross-block selection - Redirect editing events to extension handlers under editableRoot
Core Data
registry.subscribe no longer listens to all stores when the store is not registered yet
Starting in WordPress 7.2, registry.subscribe( listener, storeName ) is more efficient when storeName isn’t registered at the time of the call.
Previously, the listener was attached to the registry-wide listener list, so it ran on every update from every store, both before and after the target store was registered. Now the registry keeps it as a pending listener and connects it to the store once it is registered, so the listener only runs for updates from that store.
Subscribing before a store is registered works as before, and the returned unsubscribe function still works. No code changes are needed. Code that relied on such a listener firing for unrelated stores will see fewer calls, but this was never documented behavior.
References:
Props to @aaronrobertshaw, @ramonopoly, @annezazu, @jsnajdr, @scruffian and @ellatrix for content.

Andrew Duthie
Thanks for leading this change, @desrosj ! I think it’ll help foster a more hospitable environment for human discussion, while still keeping those notifications available for people who want them.
At least as of a few minutes ago, I still see Gutenberg GitHub commits being shared in #core-editor-commits. Is that expected?
Reply
Lance Willett
Works well so far after joining a few today. Thanks for the focus and split.
Reply