Jonathan Desrosiers 5:08 pm on March 27, 2026
Tags:   

WordPress 7.0 Release Candidate Phase, Pt. 2

This updates the expectations and policies that should be followed through the final release of WordPress 7.0 following the previous post and the release of RC2 on 26 March.

These policies mainly cover how and when CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. committers can commit. For non-committing contributors, this post may help explain why Core committers make certain decisions.

Trunktrunk A directory in Subversion containing the latest development code in preparation for the next major release cycle. If you are running "trunk", then you are on the latest revision. is now WordPress 7.1-alpha

WordPress 7.0 has been copied to its own branch, trunk is now open for commits for the next version of the software.

Backporting to the 7.0 branchbranch A directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch".

Backporting commits of production code (that is, anything that ends up in the zip file) now requires double sign-off by two core committers. The dev-feedback keyword should be used to request a second committercommitter A developer with commit access. WordPress has five lead developers and four permanent core developers with commit access. Additionally, the project usually has a few guest or component committers - a developer receiving commit access, generally for a single release cycle (sometimes renewed) and/or for a specific component.’s review, dev-reviewed should be added to indicate a second committer has reviewed and approved the commit to the 7.0 branch.

String Freeze

The RC1 release marked the hard string freeze point of the release cycle and that continues. Strings will be available for Polyglots contributors shortly. Please subscribe to the Make Polyglots blog for updates.

No new strings are permitted. Exceptions can be made for critical strings (the About page, for example) provided they are properly tagged with the i18n-change keyword in TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. and the Polyglot team is made aware. Existing strings can be removed and/or duplicated as necessary.

Seek guidance from the Polyglots team reps for any strings reported as buggy. A buggy string is one that can not be translated to all languages in its current form. 

Tickets on the WordPress 7.0 milestone

For the remainder of the cycle, only two types of tickets may be placed on/remain on the 7.0 milestone:

  • Regressions: bugs that have been introduced during the WordPress 7.0 development cycle, either to existing or new features.
  • Test suite expansion: tests can be committed at any time without regard to code or string freezes. This can cover either new or existing features.

Please make sure to observe all code freezes, which applies to changes of any kind. Coordinate with the release squad in the #7-0-release-leads channel in SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ if there is a change you feel should be committed during a freeze.

Props @jorbin, @audrasjb, @amykamala for peer review.

#7-0

Dean Sas 5:27 pm on March 25, 2026
Tags: , , ,   

What’s new in Gutenberg 22.8? (25 March)

“What’s new in GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/…” posts (labeled with the #gutenberg-new tag) are posted following every Gutenberg release on a biweekly basis, showcasing new features included in each release. As a reminder, here’s an overview of different ways to keep up with Gutenberg and the Editor.

Gutenberg 22.8 has been released and is available for download!

Table of contents

Real-time Collaboration improvements

Real-time collaboration now shows collaborator text selections, not just cursor positions. When another user selects text, you see their selection highlighted in their assigned colour — matching the behaviour you’d expect from collaborative editors like Google Docs.

The presence UIUI User interface has also been polished: avatars are redesigned, you can now see your own presence indicator, and a new Writing preference lets you control whether you receive collaborator notifications. Under the hood, peer limits and disconnection debouncing improve stability for busier editing sessions. (76107, 75652, 76413, 76460, 76565, 76114)

Button pseudo-state styling in Global Styles

A new “State” dropdown now appears next to the Button 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. title in Global Styles. Selecting a state — Hover, Focus, or Active — switches all the style controls below to edit that specific state. The block preview updates live to show the selected state, giving you a visual preview of how the button will appear on the frontend.

While theme.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. has supported pseudo selectors for some time, there has been no visual interface to edit them until now. The Button block is the starting point, with the architecture designed to expand to other blocks in future releases. Separately, theme.json now also supports styling the current/active 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. item and its interactive states, giving theme authors control over active-page highlighting without custom CSSCSS Cascading Style Sheets.. (75627, 75736, 76326)

Site Logo & Icon in the Design panel

Site logo and icon management now has its own dedicated screen in the Design panel. The new screen uses a compact media editor for both fields, making it quicker to set or swap your site’s logo and favicon without navigating through adminadmin (and super admin) settings or finding the block settings. (76116)

Connectors extensibility

The Connectors screen, introduced in 22.7, now has a registry 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. that allows plugins to register their own connectors. Plugins can use registerConnector() to add entries to the Connectors admin page, and unregisterConnector() to remove them.

These extension points allow any 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 integrate with the Connectors system, so it can grow beyond the built-in providers. (76364, 76541, 76142).

Other Notable Highlights

  • Add navigation links from sidebarSidebar A sidebar in WordPress is referred to a widget-ready area used by WordPress themes to display information that is not a part of the main content. It is not always a vertical column on the side. It can be a horizontal rectangle below or above the content area, footer, header, or any where in the theme. List View: You can now add new links directly from the Site Editor’s sidebar List View for navigation menus, rather than needing to open the block inspector. (75918)
  • Client-side media processing: Client-side image uploads now support the AVIF format, cross-origin isolation no longer breaks third-party plugin iframes, and server-side plugins that process uploaded images (for watermarking, CDN sync, etc.) now work correctly alongside client-side processing. (76371, 75991, 74913, 76616)
  • Command Palette in the admin bar: A trigger button for the Command Palette now appears in the WordPress admin bar, making it accessible from anywhere in the admin. The button displays the keyboard shortcut for your platform (⌘K on Mac, Ctrl+K on Windows/Linux). (75757)

Changelog

Features

Collaboration

  • RTC: Add preference for collaborator notifications. (76460)

Enhancements

Components

  • wordpress/ui: Add Collapsible component. (76280)
  • Add ExampleApplication story for ThemeProvider to better demonstrate component theme-ability.
    (76463)
  • Add Link primitive to @wordpress/ui. (76013)
  • Add primitive Text component to wordpress/ui. (75870)
  • Add styles for outside days in Calendar components. (76199)
  • Admin UI: Add Storybook stories for Breadcrumbs and Page components. (76467)
  • Adopt surface-width design tokens for Dialog, Notice, and Modal widths. (76494)
  • Collapsible.Card: Make contents hidden until found. (76498)
  • CollapsibleCard: Move trigger to the whole 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.. (76265)
  • Editor: Polish real-time collaboration presence UI and move 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. to editor package.
    (75652)
  • Field.Label, Fieldset.Legend: Add visuallyHidden prop. (76052)
  • Refactor admin-ui Page component to use wordpress/theme tokens and wordpress/ui layout primitive.
    (75963)
  • Storybook: Change the default font. (76366)
  • Storybook: Deduplicate injected package stylesheets. (76158)
  • Theme package: Add surface width design tokens. (76047)
  • Theme: Add no-token-fallback-values stylelint rule. (76415)
  • Tooltip: Change default placement from bottom to top. (76131)
  • UI Notice: Let description and actions span icon column at narrow widths. (76202)
  • UI/Badge: Add border and neutral-strong background to none intent. (76356)
  • @wordpress/ui: Add Card and CollapsibleCard components. (76252)
  • CollapsibleCard: Add animations. (76378)
  • ui/Card: Increase padding, align with legacy Card. (76368)
  • Admin UI: Update font size for title and breadcrumbs to match. (76452)

Connectors

  • Add AI Experiments plugin callout with install/activate functionality. (76379)
  • Add connectors registry for extensibility. (76364)
  • Add empty state when no connectors are registered. (76375)
  • Add unregisterConnector and upsert support. (76541)
  • Move plugin status computation to script module data. (76409)
  • Sync PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher code with WordPress CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress.. (76443)
  • Update page identifier to options-connectors. (76142)
  • WP Admin: Update Connectors screen footer text for consistency. (76382)

Block Library

  • Block Library: Improve the design of MediaControlPreview and MediaControl.
    (76430)
  • Link Picker: Use Homepage badge instead of Page if Homepage. (75929)
  • Navigation link: Add support to style current menu item via theme.json. (75736)
  • Navigation: Allow creating new links in site editor sidebar List View. (75918)
  • Post Date: Migrate to textAlign block support. (75856)
  • Post 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.: Migrate to textAlign block support. (75860)
  • Tabs: Disable anchor support on Tab Menu Item. (76442)
  • Tabs: Restructure Tabs Menu and inner blocks. (75954)

DataViews

  • Add border to sticky table headers. (76396)
  • DataForm: Add customizable button text to panel modal. (76099)
  • DataForm: Reduce panel‘s dialog min-width. (76345)
  • DataViews Grid and Picker Grid: Add density option for gap between items. (75887)
  • Improve storybook infinite scroll. (76566)

Post Editor

  • Add Site Logo & Icon screen to Design panel. (76116)
  • Editor: Show own presence in collaborative editing sessions. (76413)
  • Fields: Add format field. (76308)
  • Media: Add 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. and extension points for client-side media processing. (74913)

Collaboration

  • RTC: Add collaborator selection highlighting in rich text. (76107)
  • RTC: Allow filtering of SyncConnectionModal. (76554)
  • RTC: Auto-register custom taxonomyTaxonomy A taxonomy is a way to group things together. In WordPress, some common taxonomies are category, link, tag, or post format. https://codex.wordpress.org/Taxonomies#Default_Taxonomies. rest_base values for CRDT sync. (75983)
  • RTC: Do not sync role=local attributes. (76267)
  • RTC: Implement disconnection debounce after initial connection. (76114)
  • RTC: Implement front-end peer limits. (76565)
  • RTC: Remove post list lock icon and replace user-specific lock text. (76322)
  • Use V2 Yjs methods for HTTPHTTP HTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands. Polling. (76304)
  • Add a limit for the default provider. (76437)

Content Guidelines

  • Rename route and use the right Notice component. (76427)

Block Editor

  • Implement state UI for pseudo selectors on Global styles. (75627)
  • Media: Use Document-Isolation-Policy for cross-origin isolation on Chromium 137+.
    (75991)
  • Pattern Editing and Block Fields: Highlight selected block. (74841)
  • Icons API: Support searching in labels. (75878)
  • Media Upload Modal: Try an uploading state with popover in the footer. (76228)
  • Set placeholder to featured imageFeatured image A featured image is the main image used on your blog archive page and is pulled when the post or page is shared on social media. The image can be used to display in widget areas on your site or in a summary list of posts. field. (76342)
  • Add confirmation dialog before disconnecting/detaching. (75713)

Interactivity API

  • Add client-side navigation block with interactive features. (76331)

Command Palette

  • Add command palette trigger button to admin bar. (75757)

Bug Fixes

Post Editor

  • Add isNavigationPostEditorKey symbol to fix menu display context. (76461)
  • Allow Post Content to be edited when ‘Show template’ is active and Post content is nested in a Template Part.
    (76305)
  • Client-side media processing: Try plumbing invalidation to the block-editor’s mediaUpload onSuccess callback.
    (76173)
  • Editor: Fix autosaves for draft and auto-draft posts. (76624)
  • Fix: Document Bar: Back button flickers. (76320)
  • Fix: QuickEdit: Consolidate how “Status > Scheduled” works. (76129)
  • Navigation: Disable Mobile Menu in Isolated Editor or Site Editor Preview. (76203)
  • Notes: Disable for in-editor revisionsRevisions The WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision.. (76180)
  • Page Parent: Change the default value of ‘fieldValue’ state. (76354)
  • Page/Post Content Focus Mode: Fix insertion into Post Content block. (76477)
  • RTC: Place sync connection modal in front of popover. (76431)
  • Revisions: Show changed block attributes in inspector sidebar. (76550)
  • Revisions: Use useSubRegistry={false} to fix global store selectors. (76152)
  • Site Editor: Ensure editor settings are populated with server-side settings ASAP.
    (75785)

Block Library

  • Cover Block: Add a playlist parameter to loopLoop The Loop is PHP code used by WordPress to display posts. Using The Loop, WordPress processes each post to be displayed on the current page, and formats it according to how it matches specified criteria within The Loop tags. Any HTML or PHP code in the Loop will be processed on each post. https://codex.wordpress.org/The_Loop YouTube background videos. (76004)
  • Disables anchor support for the Page Break block. (76434)
  • Fix: Update the playlist-track file permissions from 755 to 644. (76315)
  • Fix: Use add_filter() for get_block_type_variations hook. (76297)
  • HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. & ShortcodeShortcode A shortcode is a placeholder used within a WordPress post, page, or widget to insert a form or function generated by a plugin in a specific location on your site.: Disable viewport visibility support. (76138)
  • HTML Block: Fix broken layout. (76278)
  • Hide template part replace button when viewing revisions. (76169)
  • Navigation Overlays: Fix submenu overflow when parent nav is right-justified.
    (76360)
  • Navigation block: Fix submenu chevron toggle on touch devices. (76197)
  • Navigation overlay close button may be displayed twice. (76585)
  • Navigation: Update close button size. (76482)
  • Playlist: Clip content to respect border-radius. (76146)
  • Show spinner when replacing media via drag-and-drop. (76245)
  • Site Title Block: Fix preview display. (76614)

Data Layer

  • Core Data: Add ‘supportsPagination’ flag for Font Collection entity. (76404)
  • Core Data: Fix ‘canUser’ returning ‘undefined’ when the allow header is missing.
    (76307)
  • Core Data: Fix per_page query logic for when offset is present in the query.
    (76613)
  • Core Data: Fix selectors returning stale results for different ‘per_page’ queries.
    (76422)
  • Core Data: Support reading revision data in useEntityProp (fixes footnotes in revisions UI).
    (76106)
  • Core Data: Treat single-item responses specially. (76318)
  • API Fetch: Respect caller-provided Content-Type in httpV1 middleware. (76285)

Connectors

  • Add logo URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org support for custom AI providers. (76190)
  • Align Gutenberg init hook priorities with Core. (76161)
  • Fetch specific plugin instead of all plugins. (76594)
  • Gate unavailable install actions behind install 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).. (75980)
  • Improve placeholder text and make it translatable. (75996)
  • Improve responsive layout for small viewport and screens. (76231, 76186)
  • Memoize getConnectors selector. (76339)
  • Move API key validation and masking to REST dispatch level. (76327)
  • Show API key source for env vars and wp-config constants. (76266)
  • Fix RTL styling on AI plugin callout banner. (76497)
  • Fix RTL styling on Connectors, Font Library, and boot-based admin pages. (76496)

Components

  • Compose: Implement useCopyToClipboard and useCopyOnClick with native clipboard API.
    (75723)
  • Fix token fallback plugins breaking JSJS JavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. strings with quoted font names. (76254)
  • InputLayout.Slot: Forward className prop. (76459)
  • Menu: Fix RadioItem controlled checked state. (76041)
  • Revert “Button: Add word-break: Break-word“. (76230)
  • TimePicker: Clamp month day to valid day for month. (76400)
  • useMediaQuery: Support in-iframeiframe iFrame is an acronym for an inline frame. An iFrame is used inside a webpage to load another HTML document and render it. This HTML document may also contain JavaScript and/or CSS which is loaded at the time when iframe tag is parsed by the user’s browser. queries via new WindowContext. (76446)

Block Editor

  • Block Bindings: Remove source items constrained by enums. (76200)
  • Fix HEIC upload error handling and sub-size format. (76514)
  • Navigation Editor: Allow any blocks to be inserted by gating contentOnly insertion rules to section blocks.
    (76189)
  • Rename and visibility modals: Gate shortcuts behind canEditBlock to prevent triggering in revisions UI.
    (76168)
  • Fix shortcode conversion when separated by
    tags. (76213)

DataViews

  • Add spinner in DataViewsLayout in initial load of data. (76486)
  • DataForm datetime control: Fix date handling. (76193)
  • Fields: Hide scheduledDateField from the list and filters. (76247)
  • Fix last column classname in table layout. (76133)
  • Fix layout scrolling in constrained-height containers. (76453)

Collaboration

  • Fix list sidebar reset during real-time collaboration. (76025)
  • Fix backportbackport A port is when code from one branch (or trunk) is merged into another branch or trunk. Some changes in WordPress point releases are the result of backporting code from trunk to the release branch. changelog PR for Gutenberg #75746. (76154)
  • Use apiFetch 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)., allow nonce refresh. (76283)
  • Fix backport changelog for #76060. (76174)
  • Verify client ID to avoid awareness mutation. (76056)
  • Disable RTC in the site editor. (76223)
  • Fix CRDT serialization of nested RichText attributes. (76597)
  • Fix TypeError in areEditorStatesEqual when selection is undefined. (76163)
  • Fix cursor index sync with rich text formatting. (76418)
  • Fix error when entity record doesn’t have ‘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.’ property. (76311)
  • Fix performance regressionregression A software bug that breaks or degrades something that previously worked. Regressions are often treated as critical bugs or blockers. Recent regressions may be given higher priorities. A "3.6 regression" would be a bug in 3.6 that worked as intended in 3.5. on post save. (76370)

Interactivity API

  • Fix router initialization race condition on Safari/Firefox. (76053)
  • Fix crypto.randomUUID crash in non-secure contexts. (76151)
  • Make Window.scheduler required to match DOM lib. (76271)

Site Editor

  • Fix block style variations not rendering in Site Editor Patterns page. (76122)
  • Site Editor > Templates: Fix author 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.. (76625)

Client Side Media

  • Media: Enable AVIF support for client-side uploads. (76371)
  • Upload Media: Loosen client-side media processing requirements. (76616)

Global Styles

  • Theme_JSON: Prevent implicit coercion in to_ruleset. (76392)
  • Fix block pseudo-state styles incorrectly applied to default state. (76326)

Patterns

  • Block context menu: Context menu not closing for disconnecting unsynced pattern menu items.
    (75405)

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)

  • Connectors: Improve accessibility. (76456)
  • Add word-break property to visually hidden styles to prevent screen reader issues.
    (75539)

Performance

Block Library

  • Add fetchpriority=low to IMG tags in collapsed Accordion Item blocks. (76336)
  • Add fetchpriority=low to IMG tags in collapsed Details blocks. (76269)
  • Duotone: Lazily load settings. (74748)
  • Image: Replace ‘getEntityRecordPermissions` with ‘canUser’. (76125)
  • Navigation Overlay: Explicitly set fetchpriority for images. (76208)

Data Layer

  • Core Data: Optimize revision selectors. (76043)
  • Revisions: Skip rendered fields in 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/ responses. (76347)

Design Tools

  • Block Visibility: Add fetchpriority=auto to IMG tags in blocks with conditional viewport visibility to prevent potential erroneous
    high loading priority. (76302)

Experiments

Post Editor

  • Add experiment: Render the editor inspector with DataForm. (76244)
  • Fields: Add post content information field. (76309)
  • Fields: Add support for classic themes in template. (76441)
  • Template field: Match exactly the behavior of post template panel. (76596)

Site Editor

  • ExtensibleExtensible This is the ability to add additional functionality to the code. Plugins extend the WordPress core software. Site Editor: Make canvas previews full height. (76201)
  • Move site editor preview CSS to boot package. (76211)
  • Sync some post list changes with Extensible Site Editor. (76243)

Documentation

  • Add Client-Side Navigation documentation to manifest and table of contents.
    (76351)
  • Data: Update documentation for global ‘dispatch’ and ‘select’ methods. (76134)
  • Docs: Document controlled/uncontrolled prop naming conventions for @wordpress/ui.
    (76281)
  • RTC: Update sync documentation. (75972)
  • Storybook: Add basic accent color guidance. (76340)
  • Storybook: Redesign Icon library page. (76034)
  • Storybook: Rename “Components (Deprecated)” to “Deprecated”. (76362)
  • Storybook: Upgrade to 10.2.8. (76403)
  • Theme: Document build plugins in README. (76003)
  • ThemeProvider: Fix tags in Storybook. (76500)
  • Update block registration methods in documentation for WordPress 6.8+. (76324)
  • theme.json schema: Fix pseudo-class definition for button block. (76272)
  • wp-env: Update JSON Schema with missing properties and add README documentation.
    (76115)

Code Quality

  • Boot: Remove manual fallbacks from design token usages. (76414)
  • Fix: Rewrite the license check scripts to use Node’s native module resolution.
    (75039)
  • Add Router type export to wordpress/route. (76139)
  • DataForm: Consolidate date and datetime input placement. (76136)

Block Library

  • HTML Block: Remove “unsaved changes” check. (76086)
  • Icon Block: Clean up selectors configuration. (75786)
  • Icons: Fix incorrect icon slug. (76074)
  • Navigation: Use the shared icon rendering functions for all navigation blocks.
    (76372)
  • Playlist: Move getTrackAttributes to utils. (76096)
  • Simplify require statements for navigation files. (76373)

Data Layer

  • Convert data package fully to TS. (76149)
  • Core Data: Fix the list of properties persisted in autosaves. (76451)

Collaboration

  • Move event hooks from editor to core-data. (76358)
  • Replace apiFetch with core-data store selectors. (76333)

Components

  • Admin UI: Use hasPadding prop in Page stories. (76601)
  • Use --wpds-cursor-control design token. (76218)

Post Editor

  • Remove redundant onNavigateToEntityRecord handling. (76523)
  • TemplateContentPanel: Fix useSelect warning. (76421)

Block Editor

  • ESLint: Add use-recommended-components rule. (76222)
  • Editor canvas iframe: Use load event and default body element. (76314)
  • Add end-to-end test for date field in QuickEdit. (76528)
  • Correct input of setIsLoading. (76381)

Tools

Build Tooling

  • Add [Package] UI label to PR labeler configuration. (76411)
  • Add support for linting annotations and other static analysis workflow improvements.
    (76120)
  • CI: Don’t build release notes during plugin build workflow for WP Core sync.
    (76398)
  • CI: Simplify strategy matrix in Build Gutenberg Plugin Zip workflow. (76435)
  • Check for IS_WORDPRESS_CORE before npm_package_config_IS_WORDPRESS_CORE.
    (76334)
  • ESLint: Add bare token check to no-unknown-ds-tokens. (76210)
  • Fix IS_GUTENBERG_PLUGIN env var override in build configuration. (76605)
  • Only run label enforcement workflow on open PRs. (76274)
  • Publish built Gutenberg plugin to 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/ Container Registry. (75844)
  • Remove function_exists checks from PHP template. (76062)
  • Upgrade actionlint and run linting when composite actions are modified. (76503)
  • Scripts: Relax wordpress/env peer dependency to allow newer versions. (76192)
  • Ensure consistent, repeatable build results when inlining WASM files via wasmInlinePlugin.
    (76113)
  • wp-build: Stop bundling Core packages, generate prerequisites asset instead.
    (75987)
  • ESLint: Broaden no-setting-ds-tokens to all object property keys. (76212)
  • ESLint: Modernize eslint-plugin rule APIs for v10 compatibility. (76507)
  • ESLint: Replace eslint-plugin-ssr-friendly with custom rules. (76508)
  • Include AI tools disclosure in pull request template. (76425)
  • Remove alexstine from codeowners. (76551)
  • Exclude experimental pages from Core builds. (76038)

Testing

  • Auto Cherry-Pick: Fix race condition in workflow trigger. (76083)
  • Fix “should undo bold” flaky test. (76464)
  • RTC: Fix ‘networkidle’ and other end-to-end tests that are flaky. (76214)
  • RTC: Fix post-editor-template-mode end-to-end test. (76209)
  • RTC: Fix tests related to publish undo stack. (76206)
  • Tests: Skip connector logo URL tests when AI Client is unavailable. (76343)
  • Update Node version to v24 for flaky test reporter. (76492)
  • end-to-end Tests: Add connector setup flow tests with test AI provider. (76433)
  • end-to-end Tests: Add coverage for AI plugin callout banner. (76432)
  • end-to-end Tests: Fix flaky autocomplete and mentions test. (76407)

First-time contributors

The following PRs were merged by first-time contributors:

  • @apermo: Fix: Use add_filter() for get_block_type_variations hook. (76297)
  • @chubes4: API Fetch: Respect caller-provided Content-Type in httpV1 middleware. (76285)
  • @kannan-ravi: Add word-break property to visually hidden styles to prevent screen reader issues. (75539)
  • @markusfoo: Interactivity API: Fix router initialization race condition on Safari/Firefox. (76053)
  • @sagarjadhav: HTML & Shortcode: Disable viewport visibility support. (76138)
  • @smithjw1: RTC: Auto-register custom taxonomy rest_base values for CRDT sync. (75983)
  • @wwahammy: Correct input of setIsLoading. (76381)

Contributors

The following contributors merged PRs in this release:

@aaronrobertshaw @adamsilverstein @aduth @alecgeatches @alexstine @Aljullu @andrewserong @annezazu @apermo @aswasif007 @CGastrell @chriszarate @chubes4 @ciampo @Copons @dabowman @desrosj @dhasilva @dlind1 @ellatrix @enejb @getdave @gigitux @gziolo @hbhalodia @huzaifaalmesbah @iamchughmayank @im3dabasia @ingeniumed @jameskoster @jasmussen @jeryj @jorgefilipecosta @jsnajdr @juanmaguitar @kannan-ravi @kraftbj @MaggieCabrera @Mamaduka @manzoorwanijk @markusfoo @mattgrshaw @maxschmeling @mcsf @mikachan @mikejolley @mirka @Mustafabharmal @ntsekouras @oandregal @ockham @pkevan @ramonjd @retrofox @sagarjadhav @scruffian @sgomes @shekharnwagh @shimotmk @simison @smithjw1 @t-hamano @talldan @westonruter @wwahammy @youknowriad @yuliyan

Props to @annezazu for reviewing and @joen for providing the design assets.

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

Olga Gleckler 5:20 pm on March 25, 2026
Tags: #wcasia2026,   

Join Core at WordCamp Asia 2026 Contributor Day (April 9, Mumbai & Online)

Want to prepare for WordCampWordCamp WordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Asia 2026 Contributor DayContributor Day Contributor Days are standalone days, frequently held before or after WordCamps but they can also happen at any time. They are events where people get together to work on various areas of https://make.wordpress.org/ There are many teams that people can participate in, each with a different focus. https://2017.us.wordcamp.org/contributor-day/ https://make.wordpress.org/support/handbook/getting-started/getting-started-at-a-contributor-day/?
Join the New CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Contributor Meeting on Thursday, 26 March 2026 at 17:00 UTC 🎉

On April 9th, 2026, the Core Teams will gather at Jio World Convention Centre, Mumbai, India, for Contributor Day at WordCamp Asia — alongside the WordPress 7.0 release celebration.

This is both a milestone moment and a working day. For more details, check the full event schedule.

Please prepare your setup at home

To have a successful day, it is essential to make everything ready. Take it seriously 📝

Downloading and installing software takes time, and trying to make things quick can lead to missing steps and a whole day of debugging in frustration. Let’s make it all calmly ahead of time and, as a result, enjoy the day. Start with forking the wordpress-develop repo to your own 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/ account and launching it locally.

Make a checkmark that it is working ✅ and be ready to enjoy the day 🚀

WordPress 7.0 Release 🎉

The morning (Thursday, 9 April 4:00 AM UTC — Thursday, 9 April 6:30 AM UTC) will focus heavily on final release activities following the major releasemajor release A release, identified by the first two numbers (3.6), which is the focus of a full release cycle and feature development. WordPress uses decimaling count for major release versions, so 2.8, 2.9, 3.0, and 3.1 are sequential and comparable in scope. flow outlined in the Core handbook. More about the release team you can find on a WordPress 7.0 release page.

Core and Test contributors may be involved in:

  • Final verification
  • Release package validation
  • Last-minute testing
  • Documentation checks

This means two things:

  1. Some contributors will be deeply engaged in release processes.
  2. Testing and real-world validation will be especially valuable.

If you plan to join in person or remotely, consider preparing a local or staging copy of a real site to test WordPress 7.0 thoroughly.

Testing flows such as:

  • Post creation
  • Media handling
  • Categories and taxonomies
  • Editor interactions
  • 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. compatibility
  • Theme behavior

Real environments surface real issues.

👉🏻 To find out more about contribution in testing, check the Core Test Team at WCAsia 2026: Contributor Day post.

Meet the Core teams table leads

These experienced contributors will guide you during the day on dedicated tables and online in SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ 🙌🏻

Rutvik Savsani,
Core
Pathan AmaanKhan,
Core
Aditya Dhade,
Core Performance
Weston Ruter,
Core Performance
Aslam Doctor,
Core AI
Deepak Gupta,
Core AI
Gajendra Singh,
Core AI
David Levine,
Core AI online
Isabel Brison,
Core Editor
Mayank Tripathi,
Core Editor
Rodrigo Primo,
WPCSWordPress Community Support A public benefit corporation and a subsidiary of the WordPress Foundation, established in 2016.

👉🏻 We are looking to have more online table leads. Please leave a comment if you are ready to lead one of the tables online at the time of the event.

What About Tickets?

If you are planning to work on TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. tickets or 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/ issues, be mindful that:

  • Work started on Contributor Day may land in 7.1 or later.
  • That’s normal.
  • 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. is iterative.

We encourage contributors to pick tickets that can make progress in a few focused hours — while remaining flexible in case release-related priorities arise.

Core Includes Gutenberg and AI

At WordCamp Asia, Core work will also include:

  • Gutenberg (the Editor)
  • Testing efforts
  • Documentation improvements
  • Performance and 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)
  • Core AI exploration (where applicable)

Contributors interested in AI-related efforts are encouraged to review the AI Team handbook beforehand.

Prepare at home 🏠

Contributor Days are significantly more productive when environments are ready.

Please set up in advance:

  • Docker or local environment
  • Node.js / npm
  • Composer
  • WordPress develop repository
  • Test suite
  • A working local installLocal Install A local install of WordPress is a way to create a staging environment by installing a LAMP or LEMP stack on your local computer.

Download dependencies ahead of time. Shared conference Wi-Fi can slow installations considerably.

If you intend to focus on testing, prepare:

  • A local copy of a real site
  • Or staging environments

Prepared contributors contribute. Unprepared contributors troubleshoot setup all day.

Docker / WordPress Development

To get started right away working with us on WordPress and the Gutenberg Editor, please make sure your technical setup is ready. You’ll need a laptop and access to all the accounts we’ve linked for you above.

WordPress Core

If you’d like to contribute directly to WordPress Core, you should start by forking the WordPress Development Repository. Then, make your changes in your own branchbranch A directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch".. Once ready, submit a pull request referencing the related ticketticket Created for both bug reports and feature development on the bug tracker. number. The system will automatically detect the number and link your patchpatch A special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. to the corresponding ticket.

➡️ Go to the repository
➡️ follow instructions in the README.md

WordPress Gutenberg Editor

To contribute to the Gutenberg Editor, you don’t necessarily need Docker. Simply fork the Gutenberg repository, make your changes in a new branch, and submit a pull request. The only requirement is a recent version of Node.js. But we do RECOMMEND setting up a local environment to test changes BEFORE submitting a PR.

➡️ Go to the repository
➡️ Setup instructions can be found here

For Experienced Contributors

We especially encourage experienced Core contributorsCore Contributors Core contributors are those who have worked on a release of WordPress, by creating the functions or finding and patching bugs. These contributions are done through Trac. https://core.trac.wordpress.org to:

  • Help onboard newcomers
  • Pair on tickets
  • Guide first patches
  • Support testing coordination
  • Share context

Contributor Day is one of the strongest entry points into long-term contribution. Mentorship on this day has lasting impact. Consider becoming a “Contributor Buddy” — follow WordCamp Asia 2026 news to find our more about this initiative 🙌🏻

For New Contributors

If this is your first time:

  • You do not need to know everything.
  • You do need curiosity and preparation (The software installation we keep talking about).
  • You are welcome.

And if you can’t travel — you can still contribute online.

Core work happens daily in Slack and Trac.

Continue Beyond April 9

If Contributor Day sparks your interest, join the New Core Contributor Meetings held on the 2nd and 4th Thursdays of each month at 17:00 UTC. Check the meetings schedule.

These sessions help newcomers:

  • Understand workflows
  • Ask questions
  • Find tickets
  • Build confidence

Contributor Day is not about collecting badges.

It’s about becoming someone who shape WordPress. It is a step to your new identity of someone who does and achieves more 💪🏻

In an era where AI can assist with code, what remains uniquely human is collaboration, judgment, and community stewardship 💭

That is what Core contribution builds.

We look forward to collaborating in Mumbai — and online 🫶🏻

Thanks to @isabel_brison, @rutviksavsani, @james-roberts and @jeffpaul for reviewing the article.

Login to Reply<\/a><\/li><\/ul><\/div>","commentTrashedActions":"

Jeffrey Paul 3:27 am on March 25, 2026
Tags:   

WordPress 7.0 Release Candidate Phase

Note: The 7.0 branchbranch A directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch". was created on 26 March. This post should be considered obsolete for the RCrelease candidate One of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). phase of the 7.0 release cycle. Refer to the updated post for expectations and policies in place.

Now that WordPress 7.0 has entered the Release Candidate phase, the following policies are in place.

These policies mainly cover how and when CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. committers can commit. For non-committing contributors, this post may help explain why Core committers make certain decisions.

Committing to Trunktrunk A directory in Subversion containing the latest development code in preparation for the next major release cycle. If you are running "trunk", then you are on the latest revision.

Due to a technical issue that must be resolved before the 7.0 branch is created, branching has been delayed until RC2 later this week (see #64393 and the relevant pull request for background on the issue).

As a result, all commits to trunk will require double sign-off by two core committers until the 7.0 branch is created.

The dev-feedback keyword should be used to request a second committercommitter A developer with commit access. WordPress has five lead developers and four permanent core developers with commit access. Additionally, the project usually has a few guest or component committers - a developer receiving commit access, generally for a single release cycle (sometimes renewed) and/or for a specific component.’s review, dev-reviewed should be added to indicate a second committer has reviewed and approved the commit to the 7.0 branch. Commits to the test suite do not require double sign-off.

String Freeze

RC1 release marks the hard string freeze point of the release cycle. While this normally means the Polyglots teamPolyglots Team Polyglots Team is a group of multilingual translators who work on translating plugins, themes, documentation, and front-facing marketing copy. https://make.wordpress.org/polyglots/teams/ can begin translating strings from the upcoming release into their local language, a version-specific branch is required. As a result, strings will not be available for translationtranslation The process (or result) of changing text, words, and display formatting to support another language. Also see localization, internationalization. until the 7.0 branch is created.

Despite this, the normal rules for hard string freeze will be followed:

  • No new strings are permitted. Exceptions can be made for critical strings (the About page, for example) provided they are properly tagged with the i18n-change keyword in TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. and the Polyglot team is made aware.
  • Existing strings can be removed and/or duplicated if needed.

Seek guidance from the Polyglots team reps for any strings reported as buggy. A buggy string is one that can not be translated to all languages in its current form. 

Tickets on the WordPress 7.0 milestone

For the remainder of the cycle, only two types of tickets may be placed on/remain on the 7.0 milestone:

  • Regressions: bugs that have been introduced during the WordPress 7.0 development cycle, either to existing or new features.
  • Test suite expansion: tests can be committed at any time without regard to code or string freezes. This can cover either new or existing features.

Bumping Trunk to WordPress 7.1-alpha

After the 7.0 branch is created following RC2, a follow-up post will be published announcing that trunk is open for commits related to the next version of the software.

Props @desrosj, @amykamala, @jorbin for peer review.

Login to Reply<\/a><\/li><\/ul><\/div>","commentTrashedActions":"

John Blackbourn 2:00 am on March 25, 2026  

WordPress 6.9.2 retrospective

The WordPress 6.9.2 release on March 10th wasn’t the smoothest, so some members of the Security Team did an internal retrospective to identify how the project can continue to improve release processes, with the aim of ensuring that users continue to have trust in minor releases. Here’s an overview of what went well, what didn’t go so well, and all the action points as a result.

6.9.2

The Security Team decided on a plan to fully ship 6.9.2 prior to starting the backports that are provided as a courtesy to older branches. Normally the commits to trunktrunk A directory in Subversion containing the latest development code in preparation for the next major release cycle. If you are running "trunk", then you are on the latest revision., the currently supported branchbranch A directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch"., and relevant backportbackport A port is when code from one branch (or trunk) is merged into another branch or trunk. Some changes in WordPress point releases are the result of backporting code from trunk to the release branch. branches are all completed before the release process starts, but this increases the time to release the supported branch and greatly increases the time pressure on the team.

The team agreed that it was a good idea to handle trunk and 6.9 prior to committing the backports, that the approach worked well, and that it facilitated shipping 6.9.2 as fast as possible.

6.9.3

Shortly after the release, an issue in 6.9.2 was reported on the support forums that affected classic themes using an unusual approach to template loading. The team paused the backport work to investigate, and decided that it warranted a fast-follow 6.9.3 release out of an abundance of caution.

The fix was shipped in 6.9.3, around eight hours after 6.9.2.

7.0 betaBeta A pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 4

It’s uncommon for a security release of WordPress to ship during the beta period of the next major releasemajor release A release, identified by the first two numbers (3.6), which is the focus of a full release cycle and feature development. WordPress uses decimaling count for major release versions, so 2.8, 2.9, 3.0, and 3.1 are sequential and comparable in scope.. This is not intentional, the situation simply doesn’t arise often. In the twenty year history of WordPress it appears to have happened three times previously (3.9.2, 4.0.1, and 6.3.2).

Shortly after the release of 6.9.2, several community members asked if a new beta of WordPress 7.0 would be released containing the security fixes. This was not originally planned but of course makes sense, as the project should encourage as many people as possible to test beta releases and not leave them on a known insecure version until the next scheduled beta.

As a result, WordPress 7.0 beta 4 was released at the same time as 6.9.3 and included both the security fixes from 6.9.2 and the template loading fix from 6.9.3.

6.9.4

Around twenty hours after 6.9.2 was released, the Security Team received a report that some of the fixes listed in the release announcement for 6.9.2 were missing from the package. The team quickly determined that three of the ten commits that were made to trunk did not get successfully merged into the 6.9 branch and were missing from the package as a result.

The merge commits were missed due to human error, but the problem should have been easily caught by the release process. There is no step in the minor releaseMinor Release A set of releases or versions having the same minor version number may be collectively referred to as .x , for example version 5.2.x to refer to versions 5.2, 5.2.1, 5.2.3, and all other versions in the 5.2 (five dot two) branch of that software. Minor Releases often make improvements to existing features and functionality. process to independently double check that all commits were successfully merged into the active branch. Sounds obvious in hindsight, but it’s a checklist oversight that’s never been spotted.

Backports

Officially only the latest version of WordPress is supported. The Security Team historically has a practice of backporting security fixes, as necessary, as a courtesy to sites on older versions in the expectation the sites will be automatically updated.

Backporting the fixes from 6.9.2/6.9.3 to 22 older branches proved to be very time consuming. While several of the branches were ready ahead of time, several were still being worked on close to release.

  • Backports back to 6.4 were completed by end of day on Tuesday March 10th.
  • Backports back to 5.3 were completed by end of day on Wednesday March 11th, mainly due to time constraints from contributors.
  • Remaining backports were blocked by a bugbug A bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. with 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/ svn server pre-commit hook that prevented pushing to the 5.2 branch and earlier, and issues with branches not syncing to the build server. The wordpress.org systems team members applied several fixes, and backports back to 4.7 were released by end of day on Friday March 13th.
  • The 6.0 branch (which will be version 6.0.12) remains unreleased due to an unresolved issue with the build. At the time of writing this branch remains unprotected.

Backporting security fixes to a large number of branches (22 at the time of writing) continues to be a source of contention between the security team and project leadership. While the effort required from the security team to backport fixes to a branch is generally proportional to the age of the branch, the bulk of the work is actually taken up by the human processes that are needed to manage such a large number of branch releases. The team are in the planning stages of some work to increase automation and streamline the backporting processes so time from human contributors can be better spent elsewhere.

Action points

As a result of the issues with 6.9.2, its fast-follow releases, 7.0 beta 4, and backporting, the security team and coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. team have some action points that will be addressed in the coming days and weeks:

  • Add unit testunit test Code written to test a small piece of code or functionality within a larger application. Everything from themes to WordPress core have a series of unit tests. Also see regression. coverage for handling stringable objects in the template_include 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. that was addressed in 6.9.3. While this is not strictly supported, the otherwise full front end breakage that can occur means we’re essentially locked in to supporting it now.
  • Update minor release checklist page to:
    • Add info about double verification of merge commits
    • Update the TTL adjustment to be a requirement instead of a nice to have
    • Remove outdated noise from the checklist, including codex changes
    • As a general rule, there should be no reason to skip a step unless it’s clearly documented why that might happen
    • Add planning info about releasing a minor during a beta or RCrelease candidate One of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). phase
    • Before bumping versions and performing a tagging commit, the built asset on the Test Build Processes workflow should be used to confirm things work as expected.
  • Backport related Build/Test Tool changes to older branches.
    • Ensure PHPUnit reports notices and warnings as exceptions.
    • Ensure all local environment scripts have catch() mechanisms in place.
  • Create ways to make it easier to test built assets on the Test Build Processes workflow.
    • Playground supports testing this asset from a pull request but not an individual commit.
    • A script could be created to download the built asset and extract the zip file into the build directory locally for testing.

Longer term, Matt Mullenweg has asked what AI-assisted tooling can be used to review changes going into releases in order to assess risk of breakage, generally assist with review, and improve quality control. This is a wider concern not specific to security releases. Hopefully we’ll hear more about that in due course.

Thanks to @peterwilsoncc, @dmsnell, @audrasjb, and @sergeybiryukov for reviewing this post prior to publishing.

Matt Mullenweg 11:24 pm on March 24, 2026  

Rethinking Left Navigation

It’s nice that plugins can hook into the left nav wherever they want, but there’s no hierarchy and things can get pretty mixed up.

Perhaps we have all the coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. WP stuff first, then at the end we have plugins, and below Plugins, plugins can register a top-level left nav if they want, and all their universe can live beneath that menu item, but there’s a clear way to get in and out of bigger ones like WooCommerce.

Being at the bottom isn’t great, but we could allow pinning or just have the most three-recently accessed plugins at the top under Dashboard, which would naturally give top billing to plugins like a LMS or ecommerce where 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. becomes the main thing people are doing with the site.

Jorge Costa 9:40 pm on March 24, 2026
Tags: , ,   

Client-Side Abilities API in WordPress 7.0

WordPress 6.9 introduced the Abilities API. 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. provides a common interface that AI agents, workflow automation tools, and plugins can use to interact with WordPress. In WordPress 7.0 we continued that work and now provide a counterpart 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 API that can be used to implement client-side abilities like navigating, or inserting blocks. This work is fundamental to integrate with browser agents/extensions and WebMCP.

Two packages

The client-side Abilities API is split into two packages:

  • @wordpress/abilities: A pure state management package with no WordPress server dependencies. It provides the store, registration functions, querying, and execution logic. Use this when you only need the abilities store without loading server-registered abilities. This package could also be used in non-WordPress projects.
  • @wordpress/core-abilities :The WordPress integration layer. When loaded, it automatically fetches all abilities and categories registered on the server via 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/ (/wp-abilities/v1/) and registers them in the @wordpress/abilities store with appropriate callbacks.

Getting started

To use the Abilities API in your pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party., you need to enqueue the appropriate script module.

When your plugin needs server-registered abilities

If your plugin needs access to abilities registered on the server (e.g., coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. abilities), enqueue @wordpress/core-abilities. This is the most common case:

add_action( 'admin_enqueue_scripts', 'my_plugin_enqueue_abilities' );
function my_plugin_enqueue_abilities() {
    wp_enqueue_script_module( '@wordpress/core-abilities' );
}

This will load both @wordpress/core-abilities and its dependency @wordpress/abilities, and automatically fetch and register all server-side abilities.

When your plugin only registers client-side abilities

If your plugin only needs to register and work with its own client-side abilities on a specific page, without needing server-registered abilities, you can enqueue just @wordpress/abilities:

add_action( 'admin_enqueue_scripts', 'my_plugin_enqueue_abilities' );
function my_plugin_enqueue_abilities( $hook_suffix ) {
    if ( 'my-plugin-page' !== $hook_suffix ) {
        return;
    }
    wp_enqueue_script_module( '@wordpress/abilities' );
}

Importing in JavaScript

Abilities API should be imported as a dynamic import, for example:

const {
    registerAbility,
    registerAbilityCategory,
    getAbilities,
    executeAbility,
} = await import( '@wordpress/abilities' );

If your client code is also a script module relying on @wordpress/scripts, you can just use the following code like any other import:

import {
    registerAbility,
    registerAbilityCategory,
    getAbilities,
    executeAbility,
} from '@wordpress/abilities';

Registering abilities

Register a categoryCategory The 'category' taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging. first

Abilities are organized into categories. Before registering an ability, its category must exist. Server-side categories are loaded automatically when @wordpress/core-abilities is enqueued. To register a client-side category:

const { registerAbilityCategory } = await import( '@wordpress/abilities' );

registerAbilityCategory( 'my-plugin-actions', {
    label: 'My Plugin Actions',
    description: 'Actions provided by My Plugin',
} );

Category slugs must be lowercase alphanumeric with dashes only (e.g., data-retrieval, user-management).

Register an ability

const { registerAbility } = await import( '@wordpress/abilities' );

registerAbility( {
    name: 'my-plugin/navigate-to-settings',
    label: 'Navigate to Settings',
    description: 'Navigates to the plugin settings page',
    category: 'my-plugin-actions',
    callback: async () => {
        window.location.href = '/wp-admin/options-general.php?page=my-plugin';
        return { success: true };
    },
} );

Input and output schemas

Abilities should define 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. Schema (draft-04) for input validation and output validation:

registerAbility( {
    name: 'my-plugin/create-item',
    label: 'Create Item',
    description: 'Creates a new item with the given title and content',
    category: 'my-plugin-actions',
    input_schema: {
        type: 'object',
        properties: {
            title: { type: 'string', description: 'The title of the item', minLength: 1 },
            content: { type: 'string', description: 'The content of the item' },
            status: { type: 'string', description: 'The publish status of the item', enum: [ 'draft', 'publish' ] },
        },
        required: [ 'title' ],
    },
    output_schema: {
        type: 'object',
        properties: {
            id: { type: 'number', description: 'The unique identifier of the created item' },
            title: { type: 'string', description: 'The title of the created item' },
        },
        required: [ 'id' ],
    },
    callback: async ( { title, content, status = 'draft' } ) => {
        // Create the item...
        return { id: 123, title };
    },
} );

When executeAbility is called, the input is validated against input_schema before execution and the output is validated against output_schema after execution. If validation fails, an error is thrown with the code ability_invalid_input or ability_invalid_output.

Permission callbacks

Abilities can include a permissionCallback that is checked before execution:

registerAbility( {
    name: 'my-plugin/admin-action',
    label: 'Admin Action',
    description: 'An action only available to administrators',
    category: 'my-plugin-actions',
    permissionCallback: () => {
        return currentUserCan( 'manage_options' );
    },
    callback: async () => {
        // Only runs if permissionCallback returns true
        return { success: true };
    },
} );

If the permission callback returns false, an error with code ability_permission_denied is thrown.

Querying abilities

Direct function calls

const {
    getAbilities,
    getAbility,
    getAbilityCategories,
    getAbilityCategory,
} = await import( '@wordpress/abilities' );

// Get all registered abilities
const abilities = getAbilities();

// Filter abilities by category
const dataAbilities = getAbilities( { category: 'data-retrieval' } );

// Get a specific ability by name
const ability = getAbility( 'my-plugin/create-item' );

// Get all categories
const categories = getAbilityCategories();

// Get a specific category
const category = getAbilityCategory( 'data-retrieval' );

Using with ReactReact React is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org and @wordpress/data

The abilities store (core/abilities) integrates with @wordpress/data, so you can use useSelect for reactive queries in React components:

import { useSelect } from '@wordpress/data';
import { store as abilitiesStore } from '@wordpress/abilities';

function AbilitiesList() {
	// Get all abilities reactively
	const abilities = useSelect(
		( select ) => select( abilitiesStore ).getAbilities(),
		[]
	);

	// Filter by category
	const dataAbilities = useSelect(
		( select ) =>
			select( abilitiesStore ).getAbilities( {
				category: 'data-retrieval',
			} ),
		[]
	);

	// abilities and dataAbilities update automatically when the store changes
}

Executing abilities

Use executeAbility to run any registered ability, whether client-side or server-side:

import { executeAbility } from '@wordpress/abilities';

try {
    const result = await executeAbility( 'my-plugin/create-item', {
        title: 'New Item',
        content: 'Item content',
        status: 'draft',
    } );
    console.log( 'Created item:', result.id );
} catch ( error ) {
    switch ( error.code ) {
        case 'ability_permission_denied':
            console.error( 'You do not have permission to run this ability.' );
            break;
        case 'ability_invalid_input':
            console.error( 'Invalid input:', error.message );
            break;
        case 'ability_invalid_output':
            console.error( 'Unexpected output:', error.message );
            break;
        default:
            console.error( 'Execution failed:', error.message );
    }
}

For server-side abilities (those registered via PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher and loaded by @wordpress/core-abilities), execution is handled automatically via the REST API. The HTTPHTTP HTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands. method used depends on the ability’s annotations:

  • readonly: true: uses GET
  • destructive: true + idempotent: true: uses DELETE
  • All other cases: uses POST

Annotations

Abilities support metadata annotations that describe their behavior:

registerAbility( {
    name: 'my-plugin/get-stats',
    label: 'Get Stats',
    description: 'Returns plugin statistics',
    category: 'my-plugin-actions',
    callback: async () => {
        return { views: 100 };
    },
    meta: {
        annotations: {
            readonly: true,
        },
    },
} );

Available annotations:

AnnotationTypeDescription
readonlybooleanThe ability only reads data, does not modify state
destructivebooleanThe ability performs destructive operations
idempotentbooleanThe ability can be called multiple times with the same result

Unregistering

Client-registered abilities and categories can be removed:

const { unregisterAbility, unregisterAbilityCategory } = await import( '@wordpress/abilities' );

unregisterAbility( 'my-plugin/navigate-to-settings' );
unregisterAbilityCategory( 'my-plugin-actions' );

Server-side abilities

Abilities registered on the server via the PHP API (wp_register_ability(), wp_register_ability_category()) are automatically made available on the client when @wordpress/core-abilities is loaded. WordPress core enqueues @wordpress/core-abilities on all adminadmin (and super admin) pages, so server abilities are available by default in the admin.

Plugins that register server-side abilities do not need any additional client-side setup. The abilities will be fetched from the REST API and registered in the client store automatically.

#7-0, #dev-notes, #dev-notes-7-0

Felix Arntz 9:18 pm on March 24, 2026
Tags: , , ,   

Introducing the AI Client in WordPress 7.0

WordPress 7.0 includes a built-in AI Client — a provider-agnostic PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher 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. that lets plugins send prompts to AI models and receive results through a consistent interface. Your pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. describes what it needs and how it needs it. WordPress handles routing the request to a suitable model from a provider the site owner has configured.

This post explains the API surface, walks through code examples, and covers what plugin developers need to know.

The entry point: wp_ai_client_prompt()

Every interaction starts with:

$builder = wp_ai_client_prompt();

This returns a WP_AI_Client_Prompt_Builder object, a fluent builder that offers a myriad of ways to customize your prompt. You chain configuration methods and then call a generation method to receive a result:

$text = wp_ai_client_prompt( 'Summarize the benefits of caching in WordPress.' )
    ->using_temperature( 0.7 )
    ->generate_text();

You can pass the prompt text directly as a parameter to wp_ai_client_prompt() for convenience, though alternatively the with_text() method is available for building the prompt incrementally.

Text generation

Here’s a basic text generation example:

$text = wp_ai_client_prompt( 'Write a haiku about WordPress.' )
    ->generate_text();

if ( is_wp_error( $text ) ) {
    // Handle error.
    return;
}

echo wp_kses_post( $text );

You can pass a JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. schema so that the model returns structured data as a JSON string:

$schema = array(
    'type'  => 'array',
    'items' => array(
        'type'       => 'object',
        'properties' => array(
            'plugin_name' => array( 'type' => 'string' ),
            'category'    => array( 'type' => 'string' ),
        ),
        'required' => array( 'plugin_name', 'category' ),
    ),
);

$json = wp_ai_client_prompt( 'List 5 popular WordPress plugins with their primary category.' )
    ->as_json_response( $schema )
    ->generate_text();

if ( is_wp_error( $json ) ) {
    // Handle error.
    return;
}

$data = json_decode( $json, true );

You can request multiple response candidates as variations for the same prompt:

$texts = wp_ai_client_prompt( 'Write a tagline for a photography blog.' )
    ->generate_texts( 4 );

Image generation

Here’s a basic image generation example:

use WordPress\AiClient\Files\DTO\File;

$image_file = wp_ai_client_prompt( 'A futuristic WordPress logo in neon style' )
    ->generate_image();

if ( is_wp_error( $image_file ) ) {
    // Handle error.
    return;
}

echo '<img src="' . esc_url( $image_file->getDataUri() ) . '" alt="">';

generate_image() returns a File DTO with access to the image data via getDataUri().

Similar to text generation, you can request multiple variations of the same image:

$images = wp_ai_client_prompt( 'Aerial shot of snowy plains, cinematic.' )
    ->generate_images( 4 );

if ( is_wp_error( $images ) ) {
    // Handle error.
    return;
}

foreach ( $images as $image_file ) {
    echo '<img src="' . esc_url( $image_file->getDataUri() ) . '">';
}

Getting the full result object

For richer metadata, e.g. covering provider and model information, use generate_*_result() instead. For example, for image generation:

$result = wp_ai_client_prompt( 'A serene mountain landscape.' )
    ->generate_image_result();

This returns a GenerativeAiResult object that provides several pieces of additional information, including token usage and which provider and which model responded to the prompt. The most relevant methods for this additional metadata are:

  • getTokenUsage(): Returns the token usage, broken down by input, output, and optionally thinking.
  • getProviderMetadata(): Returns metadata about the provider that handled the request.
  • getModelMetadata(): Returns metadata about the model that handled the request (through the provider).

The GenerativeAiResult object is serializable and can be passed directly to rest_ensure_response(), making it straightforward to expose AI features through 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/.

Available generate_*_result() methods:

  • generate_text_result()
  • generate_image_result()
  • convert_text_to_speech_result()
  • generate_speech_result()
  • generate_video_result()

Use the appropriate method for the modality you are working with. Each returns a GenerativeAiResult object with rich metadata.

Model preferences

The models available on each WordPress site depends on which AI providers the administrators of that site have configured in the Settings > Connectors screen.

Since your plugin doesn’t control which providers are available on each site, use using_model_preference() to indicate which models would be ideal. The AI Client will use the first model from that list that is available, falling back to any compatible model if none are available:

$text_result = wp_ai_client_prompt( 'Summarize the history of the printing press.' )
    ->using_temperature( 0.1 )
    ->using_model_preference(
        'claude-sonnet-4-6',
        'gemini-3.1-pro-preview',
        'gpt-5.4'
    )
    ->generate_text_result();

This is a preference, not a requirement. Your plugin should function without it. Keep in mind that you can test or verify which model was used by looking at the full result object, under the providerMetadata and modelMetadata properties.

If you don’t specify a model preference, the first model encountered across the configured providers that is suitable will be used. It is up to the individual provider implementations to sort the provider’s models in a reasonable manner, e.g. so that more recent models appear before older models of the same model family. The three initial official provider plugins (see below) organize models in that way, as recommended.

Feature detection

Not every WordPress site will have an AI provider configured, and not every provider supports every 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 every option. Before showing AI-powered UIUI User interface, check whether the feature can work:

$builder = wp_ai_client_prompt( 'test' )
    ->using_temperature( 0.7 );

if ( $builder->is_supported_for_text_generation() ) {
    // Safe to show text generation UI.
}

These checks do not make API calls. They use deterministic logic to match the builder’s configuration against the 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). of available models. As such, they are fast to run and there is no cost incurred by calling them.

Available support check methods:

  • is_supported_for_text_generation()
  • is_supported_for_image_generation()
  • is_supported_for_text_to_speech_conversion()
  • is_supported_for_speech_generation()
  • is_supported_for_video_generation()

Use these to conditionally load your UI, show a helpful notice when the feature is unavailable, or skip registering UI altogether. Never assume that AI features will be available just because WordPress 7.0 is installed.

Advanced configuration

System instructions

$text = wp_ai_client_prompt( 'Explain caching.' )
    ->using_system_instruction( 'You are a WordPress developer writing documentation.' )
    ->generate_text();

Max tokens

$text = wp_ai_client_prompt( 'Explain quantum computing in complicated terms.' )
    ->using_max_tokens( 8000 )
    ->generate_text();

Output file type and orientation for images

use WordPress\AiClient\Files\Enums\FileTypeEnum;
use WordPress\AiClient\Files\Enums\MediaOrientationEnum;

$result = wp_ai_client_prompt()
    ->with_text( 'A vibrant sunset over the ocean.' )
    ->as_output_file_type( FileTypeEnum::inline() )
    ->as_output_media_orientation( MediaOrientationEnum::from( 'landscape' ) )
    ->generate_image_result();

Multimodal output

use WordPress\AiClient\Messages\Enums\ModalityEnum;

$result = wp_ai_client_prompt( 'Create a recipe for a chocolate cake and include photos for the steps.' )
    ->as_output_modalities( ModalityEnum::text(), ModalityEnum::image() )
    ->generate_result();

if ( is_wp_error( $result ) ) {
    // Handle error.
    return;
}

foreach ( $result->toMessage()->getParts() as $part ) {
    if ( $part->isText() ) {
        echo wp_kses_post( $part->getText() );
    } elseif ( $part->isFile() && $part->getFile()->isImage() ) {
        echo '<img src="' . esc_url( $part->getFile()->getDataUri() ) . '">';
    }
}

Additional builder methods

The full list of configuration methods is available via the WP_AI_Client_Prompt_Builder class. Key methods include:

ConfigurationMethod
Prompt textwith_text()
File inputwith_file()
Conversation history (relevant for multi-turn / chats)with_history()
System instructionusing_system_instruction()
Temperatureusing_temperature()
Max tokensusing_max_tokens()
Top-p / Top-kusing_top_p(), using_top_k()
Stop sequencesusing_stop_sequences()
Model preferenceusing_model_preference()
Output modalitiesas_output_modalities()
Output file typeas_output_file_type()
JSON responseas_json_response()

Error handling

wp_ai_client_prompt() generator methods return WP_Error on failure, following WordPress conventions:

$text = wp_ai_client_prompt( 'Hello' )
    ->generate_text();

if ( is_wp_error( $text ) ) {
    // Handle the error.
}

When used in a REST API callback, both GenerativeAiResult and WP_Error can be passed to rest_ensure_response() directly:

function my_rest_callback( WP_REST_Request $request ) {
    $result = wp_ai_client_prompt( $request->get_param( 'prompt' ) )
        ->generate_text_result();

    return rest_ensure_response( $result );
}

If an error occurs, it will automatically have a semantically meaningful 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. response code attached to it.

Controlling AI availability

For granular control, the wp_ai_client_prevent_prompt 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. allows preventing specific prompts from executing:

add_filter(
    'wp_ai_client_prevent_prompt',
    function ( bool $prevent, WP_AI_Client_Prompt_Builder $builder ): bool {
        // Example: Block all prompts for non-admin users.
        if ( ! current_user_can( 'manage_options' ) ) {
            return true;
        }
        return $prevent;
    },
    10,
    2
);

When a prompt is prevented:

  • No AI call is attempted.
  • is_supported_*() methods return false, allowing plugins to gracefully hide their UI.
  • generate_*() methods return a WP_Error.

Architecture

The AI Client in WordPress 7.0 consists of two layers:

  1. PHP AI Client (wordpress/php-ai-client) — A provider-agnostic PHP SDK bundled in CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. as an external library. This is the engine that handles provider communication, model selection, and response normalization. Since it is technically a WordPress agnostic PHP SDK which other PHP projects can use too, it uses camelCase method naming and makes use of exceptions.
  1. WordPress wrapper — Core’s WP_AI_Client_Prompt_Builder class wraps the PHP AI Client with WordPress conventions: snake_case methods, WP_Error returns, and integration with WordPress HTTP transport, the Abilities API, the Connectors/Settings infrastructure, and the WordPress 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. system.

The wp_ai_client_prompt() function is the recommended entry point. It returns a WP_AI_Client_Prompt_Builder instance that catches exceptions from the underlying SDK and converts them to WP_Error objects.

Credential management

API keys are managed through the Connectors API. AI provider plugins that register with the PHP AI Client’s provider registry get automatic connector integration — including the Settings > Connectors adminadmin (and super admin) UI for API key management. Plugin developers using the AI Client to build features do not need to handle credentials at all.

Official provider plugins

WordPress Core does not bundle any AI providers directly. Instead, they are developed and maintained as plugins, which allows for more flexible and rapid iteration speed, in accordance with how fast AI evolves. The AI Client in WordPress Core provides the stable foundation, and as an abstraction layer is sufficiently detached from provider specific requirements that may change overnight.

While anyone is able to implement new provider plugins, the WordPress project itself has developed three initial flagship implementations, to integrate with the most popular AI providers. These plugins are:

Separately available: Client-side 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 API

A JavaScript API with a similar fluent prompt builder is available via the wp-ai-client package. It uses REST endpoints under the hood to connect to the server-side infrastructure. This API is not part of Core, and it is still being evaluated whether this approach is scalable for general use. Because the API allows arbitrary prompt execution from the client-side, it requires a high-privilege capability check, which by default is only granted to administrators. This restriction is necessary to prevent untrusted users from sending any prompt to any configured AI provider. As such, using this approach in a distributed plugin is not recommended.

For now, the recommended approach is to implement individual REST API endpoints for each specific AI feature your plugin provides, and have your JavaScript functionality call those endpoints. This allows you to enforce granular permission checks and limit the scope of what can be executed from the client-side. It also keeps the actual AI prompt handling and configuration fully scoped to be server-side only.

MigrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. from php-ai-client and wp-ai-client

If you have been using these packages in your plugin(s) before, here’s what to know.

Recommended: require WordPress 7.0

The simplest path is to update your plugin’s Requires at least 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. to 7.0 and remove the Composer dependencies on wordpress/php-ai-client and its transitive dependencies.

Replace any AI_Client::prompt() calls with wp_ai_client_prompt().

For the wordpress/wp-ai-client package, if you are not using the package’s REST API endpoints or JavaScript API, you can simply remove it as a dependency, since everything else it does is now part of WordPress Core.

If you must support WordPress < 7.0

PHP AI Client (wordpress/php-ai-client)

If your plugin still needs to run on WordPress versions before 7.0 while also bundling wordpress/php-ai-client, you will need a conditional autoloader workaround. The PHP AI Client and its dependencies are now loaded by Core on 7.0+, so loading them again via Composer will cause conflicts (duplicate class definitions).

The solution: only register your Composer autoloader for these dependencies when running on WordPress versions before 7.0:

if ( ! function_exists( 'wp_get_wp_version' ) || version_compare( wp_get_wp_version(), '7.0', '<' ) ) {
    require_once __DIR__ . '/vendor/autoload.php';
}

Due to how Composer’s autoloader works — loading all dependencies at once rather than selectively — a more granular approach was not feasible. This means the conditional check needs to wrap the entire autoloader. Alternatively, break your PHP dependencies apart in two separate Composer setups, one that can always be autoloaded, and another one for the wordpress/php-ai-client package and its dependencies only, which would be conditionally autoloaded.

WP AI Client (wordpress/wp-ai-client)

The wordpress/wp-ai-client package handles the WordPress 7.0 transition automatically. On 7.0+, it disables its own PHP SDK infrastructure (since Core handles it natively) but keeps the REST API endpoints and JavaScript API active, as those aren’t in Core yet.

You can continue loading this package unconditionally. It detects the WordPress version and only activates the parts that aren’t already provided by Core. No conditional loading needed. However, make sure to stay up to date on this package, because it will likely be discontinued soon, in favor of moving the REST API endpoints and JavaScript API into 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/. There are ongoing discussions on whether these should be merged into Core too, see #64872 and #64873.

See the WP AI Client upgrade guide for additional migration details.

Additional resources

  • TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. ticketticket Created for both bug reports and feature development on the bug tracker.: #64591
  • PHP AI Client (bundled library)
  • WP AI Client (original package, now mostly merged into Core)
  • Original merge proposal

Props to @gziolo @nilambar @laurisaarni @justlevine for reviewing this post.

Login to Reply<\/a><\/li><\/ul><\/div>","commentTrashedActions":"

Jb Audras 6:28 am on March 24, 2026
Tags: , , ,   

Dev Chat Agenda – March 25, 2026

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

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

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

Announcements 📢

WordPress 7.0 Updates

  • WP 7.0 unplanned Beta 6 released on March 20, 2026
  • WP 7.0 RC1 was delayed to March 24, 2026
  • New 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.:

General

Discussions 💬

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

Open floor  🎙️

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

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

Login to Reply<\/a><\/li><\/ul><\/div>","commentTrashedActions":"

Amy Kamala 9:47 pm on March 20, 2026
Tags: 7.0,   

WordPress 7.0 Beta 6

WordPress 7.0 BetaBeta A pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 6 is ready for download and testing!

This version of the WordPress software is still under development. Please do not install, run, or test this version of WordPress on production or mission-critical websites. Instead, it’s recommended to test Beta 6 on a test server and site.

WordPress 7.0 Beta 6 can be tested using any of the following methods:

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.Install and activate the WordPress Beta Tester plugin on a WordPress install. (Select the “Bleeding edgebleeding edge The latest revision of the software, generally in development and often unstable. Also known as trunk.” channel and “Beta/RCrelease candidate One of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). Only” stream.)
Direct DownloadDownload the Beta 6 version (zip) and install it on a WordPress website.
Command LineUse this WP-CLI command: wp core update --version=7.0–beta6
WordPress PlaygroundUse the WordPress Playground instance to test the software directly in your browser.  No setup required – just click and go! 

The scheduled final release date for WordPress 7.0 is still April 9, 2026.  The full release schedule can be found here. Your help testing Beta and RC versions is vital to making this release as stable and powerful as possible. Thank you to everyone who helps with testing!

Please continue checking the Make WordPress Core blog for 7.0-related posts in the coming weeks for more information.

What’s new in WordPress 7.0? Check out the Beta 1 announcement and Developer Notes for details and highlights.

This is an extra beta

Testing for issues is critical to the development of any software, and testing works!

Thanks to your help testing, some issues with image optimization, and package size were identified in Beta 5. This Beta ships with a reduced package size, and reverts the Client-side Media Processing feature. Real Time Collaboration is opt-in by default, with a WP_ALLOW_COLLABORATIONconstant available for control at the configuration level. Beta 6 also includes a number of fixes and performance improvements, including a 4x increase to Real Time Collaboration polling intervals to minimize 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. requests and server load.

WordPress 7.0 Beta 6 contains more than 132 updates and fixes since the Beta 5 release, including 74 in the Editor and 57 in CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress.. You can browse the technical details for all issues addressed since Beta 5 using these links:

The next 7.0 release (RC1), is scheduled for Tuesday, March 24th, and the final release on April 9, 2026 is still on track. As always, a successful release depends on your confirmation during testing. So please download and test!

How to test this release

Your help testing the WordPress 7.0 Beta 6 version is key to ensuring that the final release is the best it can be. While testing the upgrade process is essential, trying out new features is equally important. This detailed guide will walk you through testing features in WordPress 7.0.

If you encounter an issue, please report it to the Alpha/Beta area of the support forums or directly to WordPress Trac if you are comfortable writing a reproducible bugbug A bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. report. You can also check your issue against a list of known bugs.

Curious about testing releases in general? Follow along with the testing initiatives in Make Core and join the #core-test channel onMaking WordPress Slack.

A Beta 6 haiku

A spring flower bud

Beta 6 breaks through the mud

and greets the warm sun.

Props to @4thhubbard, @chaion07, and @ellatrix for proofreading and review.

Login to Reply<\/a><\/li><\/ul><\/div>","commentTrashedActions":"