The WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. development team builds WordPress! Follow this site for general updates, status reports, and the occasional code debate. There’s lots of ways to contribute:
Found a bugbugA 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.?Create a ticket in the bug tracker.
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 CoreCoreCore 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.
TrunktrunkA 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 branchbranchA 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 committercommitterA 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 TracTracAn 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.
“What’s new in GutenbergGutenbergThe 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.
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 UIUIUser 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 blockBlockBlock 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.jsonJSONJSON, 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 MenuA 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 CSSCSSCascading 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 APIAPIAn 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 pluginPluginA 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 sidebarSidebarA 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)
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 headerHeaderThe 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 AvatarAvatarAn 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)
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 PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher code with WordPress CoreCoreCore 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 ExcerptExcerptAn 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)
Media: Add hooksHooksIn 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: Remove post list lock icon and replace user-specific lock text. (76322)
Use V2 Yjs methods for HTTPHTTPHTTP 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)
Media Upload Modal: Try an uploading state with popover in the footer. (76228)
Set placeholder to featured imageFeatured imageA 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: QuickEdit: Consolidate how “Status > Scheduled” works. (76129)
Navigation: Disable Mobile Menu in Isolated Editor or Site Editor Preview. (76203)
Notes: Disable for in-editor revisionsRevisionsThe 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 loopLoopThe 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)
HTMLHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. & ShortcodeShortcodeA 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)
API Fetch: Respect caller-provided Content-Type in httpV1 middleware. (76285)
Connectors
Add logo URLURLA 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 capabilitycapabilityA 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)
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 JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. strings with quoted font names. (76254)
TimePicker: Clamp month day to valid day for month. (76400)
useMediaQuery: Support in-iframeiframeiFrame 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 backportbackportA 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 capabilitiescapabilityA 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 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 ‘metaMetaMeta 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 regressionregressionA 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 filterFilterFilters 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)
AccessibilityAccessibilityAccessibility (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)
Revisions: Skip rendered fields in REST APIREST APIThe 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
ExtensibleExtensibleThis 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)
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 GitHubGitHubGitHub 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)
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 GitHubGitHubGitHub 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 releaseA 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:
Some contributors will be deeply engaged in release processes.
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
PluginPluginA 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
👉🏻 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 TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. tickets or GutenbergGutenbergThe 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 SourceOpen 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 accessibilityAccessibilityAccessibility (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 InstallA 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 branchbranchA 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 ticketticketCreated for both bug reports and feature development on the bug tracker. number. The system will automatically detect the number and link your patchpatchA 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.
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.
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 🫶🏻
Note: The 7.0 branchbranchA 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 candidateOne 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.
These policies mainly cover how and when CoreCoreCore 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 TrunktrunkA 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 committercommitterA 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 TeamPolyglots 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 translationtranslationThe 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 TracTracAn 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.
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 trunktrunkA 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 branchbranchA 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 backportbackportA 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 betaBetaA 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 releaseA 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 ReleaseA 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 bugbugA 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.orgThe 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 coreCoreCore 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 testCode 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_includefilterFilterFilters 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 candidateOne 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.
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 coreCoreCore 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 pluginPluginA 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.
WordPress 6.9 introduced the Abilities API. The APIAPIAn 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 JavaScriptJavaScriptJavaScript 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 APIThe 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 pluginPluginA 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., coreCoreCore 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:
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:
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 categoryCategoryThe '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:
Abilities should define JSONJSONJSON, 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' );
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 PHPPHPThe 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 HTTPHTTPHTTP 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:
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.
WordPress 7.0 includes a built-in AI Client — a provider-agnostic PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higherAPIAPIAn 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 pluginPluginA 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 JSONJSONJSON, 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:
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 APIThe 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 capabilitycapabilityA 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 UIUIUser 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 capabilitiescapabilityA 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();
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:
Configuration
Method
Prompt text
with_text()
File input
with_file()
Conversation history (relevant for multi-turn / chats)
with_history()
System instruction
using_system_instruction()
Temperature
using_temperature()
Max tokens
using_max_tokens()
Top-p / Top-k
using_top_p(), using_top_k()
Stop sequences
using_stop_sequences()
Model preference
using_model_preference()
Output modalities
as_output_modalities()
Output file type
as_output_file_type()
JSON response
as_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:
If an error occurs, it will automatically have a semantically meaningful HTTPHTTPHTTP 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_promptfilterFilterFilters 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:
PHP AI Client (wordpress/php-ai-client) — A provider-agnostic PHP SDK bundled in CoreCoreCore 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.
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 hooksHooksIn 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 > Connectorsadminadmin(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 JavaScriptJavaScriptJavaScript 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.
MigrationMigrationMoving 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 headerHeaderThe 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:
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 GutenbergGutenbergThe 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.
TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress.ticketticketCreated for both bug reports and feature development on the bug tracker.: #64591
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 ticketticketCreated 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.
New Dev Notesdev noteEach 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.:
The discussion section of the agenda is for discussing important topics affecting the upcoming release or larger initiatives that impact the CoreCoreCore 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.
WordPress 7.0 BetaBetaA 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:
PluginPluginA 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 edgeThe latest revision of the software, generally in development and often unstable. Also known as trunk.” channel and “Beta/RCrelease candidateOne 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.)
Use this WP-CLI command: wp core update --version=7.0–beta6
WordPress Playground
Use 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!
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 HTTPHTTPHTTP 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 CoreCoreCore 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 bugbugA 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.
You must be logged in to post a comment.