Archives

Jonathan Desrosiers 6:53 pm on April 2, 2026  

The Path Forward for WordPress 7.0

It was announced earlier this week that the final 7.0 release has been delayed specifically to allow more time to address testing feedback about the implementation of real-time collaboration. While the broad reasons for the delay were shared, this post will clarify what the delay means in practice (“returning to 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.” after entering the Release Candidaterelease candidate One of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). phase of a release is unprecedented), and how to handle some specific technical details. Having clear guidance helps to direct attention to the right areas and ensures that the delay is as minimal as necessary.

This post outlines the policies dictating what can move forward, and the processes that should be followed until further notice to best focus community efforts while promoting stability and the ability to remain nimble.

Committing

To help CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. committers understand what types of commits are allowed during this pause, the following policies are now (or continue to be) in place:

For non-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. contributors, this section may help explain why Core committers make certain decisions.

Commits to trunk

To avoid the potential for merge conflicts while backporting and other complexities, 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 closed to commits for the 7.1 release until further notice.

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 will continue to require double sign-off by two core committers. The commit dev-feedback keywords should be used to request a second committer’s review, and dev-reviewed should be added to indicate a second committer has reviewed and approved performing the merge to the 7.0 branch.

Changes Allowed

The typical rules followed during the Release Candidate phase of the release cycle will remain in effect:

  • No new features or enhancements are allowed.
  • Only fixes for bugs introduced during the current release cycle are allowed.
  • Built/Test Tool and/or test coverage improvements are allowed at any time.
  • Features can be removed if they are deemed particularly risky, unstable, or new testing data surfaces previously undiscovered issues.

Note: These restrictions also apply to the wp/7.0 branch in the GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ repository, which is used to merge changes targeted for the 7.0 release into wordpress-develop.

The primary exceptions to the rules above are any changes related to the stability of real-time collaboration (see #64696, #64904, #64890, #65008, #64622 and this board on GitHub), and any improvements necessary to refine the experience of the new Connectors adminadmin (and super admin) screen (see #64960 and #64789).

Pre-release Versions During Delay

To allow everyone a chance to regroup and properly identify the outstanding issues and discuss how best to address them, additional pre-release versions of WordPress 7.0 will be paused through April 17th.

Enough of the surrounding context about the work remaining will be better understood by then. The release squad and project leadership can then develop a new, well informed schedule for the 7.0 final stretch, which will be published no later than April 22nd.

Testing During This Pause

Following standard procedures during a major version release cycle, the nightly releases are now being generated from the 7.0 branch. During this pause, it is recommended that you perform testing using the latest nighty build.

The easiest way to accomplish this is by installing and activating the WordPress Beta Tester 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. on a test site and selecting the “Bleeding edgebleeding edge The latest revision of the software, generally in development and often unstable. Also known as trunk.” channel and “Nightlies” stream.

Version Numbering

While the nature of the pause suggests that the release is returning to the beta phase, truly returning to beta releases from a version string perspective is challenging due to a number of technical limitations. Mainly, version_compare() will not recognize 7.0-beta7 as newer than 7.0-RC2.

After considering a number of ways to approach the situation and discussing with contributors, I’ve concluded that the best option seems to be continuing releases in the expected numerical order (RCX+1). This is a bit unorthodox because RC3 and likely RC4 will be represented as Release Candidates by version string despite being considered a beta release in practice. But it’s the most technically sound option to ensure minimal confusion around which version to test, and that sites continue to update as expected when future versions are published.

Each release post must clearly mention this nuance with clear testing instructions and guidance to avoid confusion.

Given that new releases are paused until April 17th, there is a bit more time to consider other options if new data or rationale is presented before then.

String Freeze

To avoid creating new work for Polyglots contributors, new strings should be avoided as much as possible. Exceptions can be made for critical strings (the About page or real-time collaboration, for example) provided they are properly tagged with the i18ni18n Internationalization, or the act of writing and preparing code to be fully translatable into other languages. Also see localization. Often written with a lowercase i so it is not confused with a lowercase L or the numeral 1. Often an acquired skill.-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.

Feedback

If a specific and compelling scenario comes up that makes clear adjustments to the above policies are required, please note them in the comments below for discussion and consideration. This post will be updated as changes to these policies are deemed necessary with each change clearly noted at the top. Additionally, changes will be announced in #core on SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ and noted in each next Dev Chat agenda.

Props @peterwilsoncc, @matveb, @annezazu, and @jorbin for peer review.

Mary Hubbard 3:41 pm on February 18, 2026  

WordPress 7.0 Product Review Meeting with @matt

We’re holding an open WordPress 7.0 product review Thursday, February 19th, and would love input from contributors across teams.

This will be a 90-minute working session to review where 7.0 stands and align on the story we’re telling as we head toward release. @matveb will lead the call as the 7.0 Release LeadRelease Lead The community member ultimately responsible for the Release..

Planned topics:

  • Adminadmin (and super admin) refresh designs
  • AI integrations and connectors
  • Key product highlights and overall direction

The goal is to leave with clear bullet points that can feed directly into the 7.0 release post and 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. presentations.

Time: DotOrg WP 7.0 Product Review
Timezones: 12:00 PM PT | 3:00 PM ET | 20:00 UTC

Zoom:
Join Zoom Meeting
https://us02web.zoom.us/j/88011010012?pwd=5eOGXBl0Ntg8tWzMJ0eNMSabZrYbgZ.1

Meeting ID: 880 1101 0012
Passcode: 811823

Felix Arntz 9:06 pm on February 3, 2026
Tags:   

Proposal for merging WP AI Client into WordPress 7.0

This proposes merging the WP AI Client into WordPress CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. for WordPress 7.0.

WP AI Client is developer infrastructure: a provider-agnostic 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. for WordPress code to call generative AI models via a consistent interface, with WordPress integrations 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. transport, event handling, caching, credentials, and a browser-friendly REST/JSJS JavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. layer.

Providing this foundation, in collaboration with the Abilities API that is already part of Core, will make WordPress ready for AI, both as a consumer and as a tool.

This merge does not ship any AI providers or automatically enable AI calls. Without explicit configuration and explicit calling code, WordPress will not send prompts or data to any external service. Site owners will be able to install plugins to enable usage of specific AI providers, built on top of this foundation.

Purpose & Goals

Goals

  • Provide a stable, provider-agnostic AI client foundation in Core, with seamless integration with the Abilities API
  • Reduce duplicated SDKs/settings pages by centralizing common infrastructure (transport, auth storage, prompt invocation, access controls).
  • Enable plugins to detect availability and gracefully disable AI features when no model is configured.

Non-goals

  • No bundled credentials or providers.
  • No end-user “AI assistant” UIUI User interface in core.
  • No product-level experiences standardized in this merge (those remain pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party./ecosystem territory for now, e.g. AI Experiments plugin).

Proposed Scope

  1. PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher API + Prompt Builder – A WordPress-friendly API to construct prompts and invoke model capabilitiescapability A capability is permission to perform one or more types of task. Checking if a user has a capability is performed by the current_user_can function. Each user of a WordPress site might have some permissions but not others, depending on their role. For example, users who have the Author role usually have permission to edit their own posts (the “edit_posts” capability), but not permission to edit other users’ posts (the “edit_others_posts” capability).. The underlying PHP AI Client will be bundled as an external library, while the WordPress specific wrapper code will become a direct part of Core.
  2. Provider/model abstraction – A consistent interface so hosts/site owners can choose providers via plugins, and plugins that use AI can remain vendor-neutral.
  3. Discoverability – Plugins can dynamically enable AI features, based on detecting whether any configured model on the site is able to respond to the relevant prompt(s).
  4. WordPress HTTP integration – Transport aligned with WP HTTP conventions and WP_Error behavior.
  5. Credentials management in wp-adminadmin (and super admin) – Admin UI/storage for provider credentials, used across plugins.
  6. REST endpoints + 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 REST-backed JS API for browser contexts (wp-admin/editor use cases).
  7. Simple control mechanism for prompt execution – A 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 allowing or disallowing certain prompts or prompt configurations, or even AI use in general.

Security, Privacy, Performance

  • Security: REST/JS execution must remain 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).-gated; secrets must not leak via REST/script data/logging.
  • Privacy: no outbound AI calls by default; calls only happen via explicit configuration + explicit invocation.
  • Performance: minimal footprint when unused; admin-only work should avoid affecting typical frontend requests.

Call for Feedback and Testing

Feedback is welcome via comments on this proposal or on the Trac ticket which has been opened for this change.

In particular, feedback is needed for:

  1. Is the REST/JS surface area and capability model appropriate for long-term support?
  2. Any missing core requirements for transport, errors, or credential storage?

As of now, there is no pull request yet. Please follow the Trac ticket to be notified when a pull request has been opened. Here are the steps you will need to follow for testing:

  1. Apply the core PR (install a test build or utilize the WordPress Playground instance from the PR) and confirm the admin credentials UI is access-limited.
  2. Configure a provider (or install/register a provider integration as needed).
  3. Run a minimal prompt test:
    • server-side (small MU plugin/snippet)
    • browser-side (JS API), verifying capability checks
  4. Verify behavior with no provider configured:
    • no unexpected networknetwork (versus site, blog) calls
    • no UI regressions
    • plugins can detect and gracefully disable AI features

Props to @isotropic @jason_the_adams @jeffpaul for collaborating on this post.

#core-ai

Matias Ventura 4:44 pm on December 11, 2025
Tags: ,   

Planning for 7.0

With 6.9 out in the world, our collective attention has already turned to 7.0. 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, together with Matt and Mary, had a call to discuss ideas and projects. There was shared excitement about this release, even if it’s just another number. This post acts as a gathering point for contributors to share what they are starting to work on and to find known areas they can contribute to. There will be another more tactical follow up with release schedule and responsibilities, this one is about the initial scope.

How to interact with this post

Please do not use this as a spot to request folks to work on features. 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/ and TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. are the best places to share feedback, talk about impact, and advocate for issues. 

Please use this post to share what you are working on, including areas you’d like to help with that may be listed here, as well as areas that you are working on that are not. Items with TBD indicate areas where contributors are needed so please comment below if you’re keen to work on those pieces.

If you were planning to work in an area listed below and don’t see your name, please be sure to comment as well and it’ll be updated. It’s intentional that this post is meant to be a place to shore up who is working on what out in the open at this early stage.

Also note this is neither comprehensive nor yet a commitment that all of these things will be part of 7.0, since many are in early stages and may not make this release. Items marked with ✅ mean the work is already merged 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/ or 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..

Table of Contents

Collaboration 

The project is getting deeper into Phase 3: Collaboration. Notes was a highlight feature in WP6.9 and there’s several improvements already planned to make it even more powerful and resilient.

Real time collaboration

  • Link: GitHub issue
  • Key considerations:
    • There’s been a lot of progress in defining the UIUI User interface and the diffing mechanics for reconciling changes. It’s in very good shape and needs to be reviewed and tested diligently, especially around compatibility with third-party blocks and plugins.
    • This feature has a stronger dependency on server support and infrastructure than usual WordPress features, so there needs to be a definition of what’s the baseline experience shipping in WordPress (for example, peer-to-peer with 1 or 2 connections) and how it can be augmented, either by WP.org, hosting providers, or plugins.
  • Contributors: @acicovic, @aduth, @alecgeatches, @czarate, @ingeniumed, @jsnajdr, @maxschmelingkc, @paulkevan, @shekharnwagh, @youknowriad

Notes i2

  • Link: GitHub issue
  • Key considerations:
    • Support partial selection inside 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. rich text fields.
    • A “suggestions” mode and interface that allows Notes to refer to specific content within a block and apply the suggestions.
    • Support for multi-block notes.
    • Add rich text support in the comments.
    • Develop a dashboard widgetWidget A WordPress Widget is a small block that performs a specific function. You can add these widgets in sidebars also known as widget-ready areas on your web page. WordPress widgets were originally created to provide a simple and easy-to-use way of giving design and structure control of the WordPress theme to the user. for recent notes.
    • More notification options (responses, follow a note, mentions).
  • Contributors: @adamsilverstein, @jeffpaul, @mamaduka 

Adminadmin (and super admin)

Improving screens across wp-admin

  • Link: TBD
  • Key considerations:
    • Explore CSS improvements that can modernize the look and feel. For example, consider making the “modern” admin color scheme the default.
    • Admin bar and editor “site hub” improvements. Make the W menu item filterable. Possibly start work as an experiment in Gutenberg.
    • Consider a “This time last year” widget for bloggers.
    • Bring grid layout customization to dashboard experience or other screens. (Possible widgets at the top of comments, etc).
  • Contributors: TBD, @fabiankaegy, @karmatosed, @mcsf

DataViews and DataForms iterations

  • Link: 7.0 iteration issue
  • Key considerations:
    • DataForms/QuickEdit/Document inspector design iterations.
    • Hierarchical post visualization.
    • Make DataViews screens extensibleExtensible This is the ability to add additional functionality to the code. Plugins extend the WordPress core software. in the site editor (templates, pages, etc).
  • Contributors: @oandregal

Design System

  • Link: GitHub issue
  • Key considerations:
    • Components are already being worked on in wordpress/ui.
    • ✅ Theming system with design tokens using wordpress/theme.
    • Start replacing key parts of the editor UI with improved components (tabs, flyout menus).
  • Contributors: @0mirka00, @aduth, @jsnajdr, @mciampini, @wildworks

Font library admin section

  • Link: Github issue
  • Key considerations:
    • ✅ Support for block themes.
    • Support for hybrid/classic themes.
  • Contributors: @youknowriad

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. 

  • Link: GitHub issue
  • Key tasks:
    • Rethink the revisions interface to be more modern, intuitive, and work with blocks.
    • Show visual diffs. 
    • Bonus: potentially tie in with collaborative editing, suggestions, and undo management.
  • Contributors: @adamsilverstein

Customizable Keyboard Shortcuts

  • Link: Github issue
  • Key considerations:
    • Build with design system components.
  • Contributors: TBD

APIs

Abilities & Workflows 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.

Upgrade to ReactReact React is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org 19

  • Link: Github issue
  • Key considerations:
    • There’s a path for the block editor in the mobile apps that should remove this dependency blockerblocker A bug which is so severe that it blocks a release..
    • Ecosystem impact.
  • Contributors: @aduth @jsnajdr @mamaduka @ralucastn @tyxla

Block API: Add validation levels

  • Links: Github issue with initial PR 
  • Key considerations:
    • The scope of this issue is to drastically reduce the amount of times a user sees a “this block is broken” message.
    • Impact on block API.
  • Contributors: @matveb @mcsf @youknowriad

Enforced iframed editor

  • Link: GitHub issue.
    • Backwards compatibility, extended testing.
    • ✅ MigrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. guide.
  • Contributors: @ellatrix, @wildworks

WP client AI API

  • Link: GitHub project
  • Key considerations:
    • An AI client and API for WordPress to communicate with any generative AI models of various 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). using a uniform API.
    • Integration with Abilities API.
    • Strictly no providers included in coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress..
    • Decide nomenclature.
    • Ideally, the minimum PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher version has to be bumped from PHP 7.2.
  • Contributors: @flixos90 @jason_the_adams

Creating blocks and patterns on the server

  • Link: GitHub issue
  • Key considerations:
    • Most of the tools for a pretty straightforward PHP-only representation of blocks and patterns, including bindings, are ready.
    • Declarative block attributes and form components.
    • Pattern creation and syntax that allows easy construction of blocks and bindings.
  • Contributors: @priethor, TBD

wordpress/build and routing (site editor)

  • Link: GitHub issue; Scripts issue
  • Key considerations.
    • Add extensibility to site editor routing.
    • Dependency on standalone font library.
    • Refactor the site editor to allow 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. authors to add their pages there.
    • ✅ Opinionated build tool for plugins.
    • Update Gutenberg – Core 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. flow.
  • Contributors: @youknowriad 

Shortblocks

Block bindings iterations

A series of improvements were identified to simplify the navigation workflow and make the experience of managing menus more intuitive and straightforward.

Simpler navigation editing

Ability to customise “mobile” overlay 

  • Link: GitHub issue
  • Key considerations:
    • Implemented as a template part.
    • Ability to customize when the overlay appears (breakpoint settings) just for navigation overlay.
  • Contributors: @get_dave, @jeryj

Customization

Over the past couple years we’ve been iterating on a series of related systems with the hope of arriving at a more streamlined editing experience of composite blocks and design patterns. We have some solid directions sketched out that are looking promising.

Explore more intuitive page navigation in the site editor

  • Link: TBD
  • Key considerations:
    • Modify the title bar to display a pages dropdown instead of empty command palette. List the pages used in the primary menu with a link to “browse all pages”. Exploration.
    • Add next/previous page links in zoomed-out view, similar to a carousel. See a preview in a zoomed out state with arrows next to preview or title bar. Exploration.
  • Contributors: @ellatrix

Pattern Editing (aka ContentOnly)

Improve template management

Responsive editing mode

Block supports and design tools:  

Blocks

Keeping the momentum on adding new blocks and new block tools to expand the palette and expressiveness offered to theme builders and users. There’s also some refinements to some fundamental aspects of blocks to make them more resilient and more consistent.

Group block attributes

  • Link: GitHub Issue
  • Key considerations:
    • Adding groups to InspectorControls (like BlockControls).
    • Add support for list representation to block API based on nav block work.
    • Implement content representation for media and rich text attributes. (Connected with contentOnly, bindings, and partially synced patterns work.)
  • Contributors: TBD

✅ Cover block: video embeds

Modernize Code editor + Code block

Lazy load the Classic block

Leverage iAPI for instant search block & submit comments without full page refresh

Writing flow + drag and drop improvements

  • Link: GitHub issue
  • Key considerations:
    • Get to a place where the drag handle from the toolbar can be entirely removed due to improved drag and drop functionality.
    • Making multi selection work on touch devices.
    • Improvements to inline insertion and inline images.
  • Contributors: @ellatrix

✅ Tabs block 

Release the Table of Contents block 

Playlist block

Slider block

Dialog block

✅ Breadcrumb block

Add more dynamic URLs via block bindings to Buttons block and Image block

Icon block

  • Link: GitHub issue
  • Key considerations:
    • Ship with a default set made out of some wordpress/icons.
    • Allow extenders to register their own sets.
  • Contributors: @mcsf @welcher

Gallery block: add lightbox support with the ability to switch between images

Introduce heading levels as Heading block variations

  • Link: Github issue; https://github.com/WordPress/gutenberg/issues/42181
  • Key considerations:
    • Show up in search and slash inserter.
    • Easy toggling in 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. inspector and transforms.
  • Contributor: @matveb

Aim to stabilize grid block

Media

Client side media work

Media editor

Designers looking across all these projects: @fcoveram, @joen, @jameskoster, @mattmiklic.

#7-0, #phase-3

Birgit Pauli-Haack 5:26 pm on December 3, 2025
Tags: , , ,   

What’s new in Gutenberg 22.2 (03 December)?

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

What's new in Gutenberg 22.2

Gutenberg 22.2 has been released and is available for download!

A total of 161 PRs were merged in Gutenberg 22.2, with 4 first-time contributors! With WordPress 6.9 released this week, many contributors were focused on bugbug A bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. fixes, performance, blockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. editor polish, and a series of 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) and developer experience improvements. There are still some great features and enhancements in this release, highlighted below.

Table of contents

Cover block video embeds

A big feature in this release is the ability to use embedded videos (like YouTube or Vimeo) as background videos in the Cover block, rather than being restricted to locally uploaded files. This is a major quality-of-life improvement for those who want to offload video hosting and bandwidth. (73023)

There’s further development on the experimental Breadcrumbs block. It now includes better handling for homepages, last item attributes, 404/search/archive pages, archive links, post type archive links, as well as support for paginated content. All of these additions are aimed at making breadcrumb navigation more robust and context-aware. (72832)(73249) (73283)(73435) (72905)

Styling options for the Math block.

Gutenberg 22.2 adds style options to the Math block in Gutenberg, addressing the inconsistency where inline math inherits paragraph styling but display math blocks previously lacked their own styling controls (73544).

standard styling option added to the Math block

Other Notable Highlights

Button Block Pseudo-state Styling

Theme designers and developers can now style button states (hover, focus, active, and focus visible) directly within the 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., making it much easier to keep all design controls centralized and consistent. This reduces the reliance on custom CSSCSS Cascading Style Sheets. for things like button hover states. (71418)

{
    "styles": {
        "blocks":{
                "core/button":{
                    "color":{
                        "background":"blue"
                    },
                    ":hover":{
                        "color":{
                        "background":"green"
                        }
                    },
                    ":focus":{
                        "color":{
                        "background":"purple"
                        }
                    }
                }
            }
    }
}

Data Views Upgrades

Data Views received several improvements, including:

  • A new “activity layout” brings a timeline-like view, perfect for things like revision history, logs, or any content that benefits from a chronological display. This layout handles interactions—like keyboard navigation—in a way that fits the timeline format. (72780)
  • The table column 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. now lets you add columns to the left or right for better customization (72929).

Changelog

List of all the changes

Block Library

  • Breadcrumbs: Add archive link if enabled in posts. (72832)
  • Breadcrumbs: Add attachment handling. (73249)
  • Breadcrumbs: Add 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. for preferred 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. and term per post type. (73283)
  • Breadcrumbs: Add post type archive link if it’s not the same as home URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org. (73435)
  • Breadcrumbs: Add support for paginated post content. (72905)
  • Cover: Add support for background videos as embeds. (73023)
  • Math: Enable styles options. (73544)
  • Tabs block: Improve store functionality. (73229)
  • Term Name, Term Count :Add example block previews. (73388)
  • [Button Block]: Add support for pseudo elements for the block and its variations on theme.json. (71418)

DataViews

  • Add insert left/right in table column header. (72929)
  • Apply background to DataViews wrapper. (73390)
  • DataForms: Add pattern validation. (73156)
  • DataForms: Update Email Control component to use envelope icon instead of a Symbol. (73184)
  • Field 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.: Add format to date field type. (72999)
  • Introduce activity layout. (72780)
  • Only apply hover styles when there are bulk actions. (73248)
  • Sticky elements inherit bg from container. (73240)
  • Theme: Add density support for surface padding. (73215)

Patterns

  • Add edit section to the list view instead of Ungroup. (73199)
  • Change the icon and label for pattern section to use the pattern icon and name. (73203)
  • Remove ungroup option for section blocks. (73183)
  • Sections: Remove hover outlines in outline mode. (73263)
  • Update pattern editing button labels. (73195)
  • contentOnly patterns: Mark patterns as contentOnly by adding metadata.patternName to the root block (patterns endpoint). (73375)

Block Editor

  • FontFamilyControl: Hard deprecate bottom margin. (73340)
  • Block Editor: Filter file input accept attribute based on upload_mimes. (73562)
  • Add cart icon. (73509)
  • templateLock: ContentOnly – support content block insertion. (73425)
  • RichText: Begin to support hiding richtext controls while having keyboard shortcuts available. (73181)
  • Add width block supports under dimensions. (71905)
  • Add text justify. (73201)

Bug Fixes

Block Library

  • Accordion Block: Trigger panel opening from URL hash or anchor link. (73357)
  • Accordion Item: Don’t use grid layout. (73501)
  • Accordion: add box-sizing:Border-box rule. (73507)
  • Fix block selection when navigation link ui is open. (73368)
  • Fix navigation tagtag A directory in Subversion. WordPress uses tags to store a single snapshot of a version (3.6, 3.6.1, etc.), the common convention of tags in version control systems. (Not to be confused with post tags.) entity binding. (73255)
  • Fix: Custom font size taking over fit text. (73241)
  • Fix: Stretch Text overflows into the padding area. (73327)
  • HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. Block: Fix scrolling within the modal. (73506)
  • HTML Block: Remove editorStyles from HTMLEditModal. (73347)
  • Image block: Set img_srcset to avoid PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher undefined var warning. (73453)
  • Math block: Fix accessibility. (73508)
  • Merge “Icon Size” and “Icon size” translationtranslation The process (or result) of changing text, words, and display formatting to support another language. Also see localization, internationalization. strings. (73325)
  • Simplify and improve navigation link creation flow. (73210)

DataViews

  • DataForm: Autofocus first input on panel view. (72322)
  • DataForm: Fix issue with array fields in layout panel. (73344)
  • Ensure primary actions are not wrapped in the list layout. (73333)
  • Field API format: Fix and use WordPress input. (73538)
  • Fields: Fix author field view when editing. (73482)
  • Fix alignment when viewing a DataView with table layout and non-default column alignment. (73398)
  • Open the filters from the column table consistently. (72998)
  • [DataForm]: The ModalContent component doesn’t properly check for fields validity – [#73330]. (73339)
  • Theme: Fix color ramp generation to avoid unmet contrasts. (73331)

Block Editor

  • Border Radius Control: Empty Values triggers unintended px unit conversion. (73324)
  • Drag and drop: Remove grab cursor for multi-selection. (73521)
  • Drag: Hide block tools popovers. (73539)
  • Stretchy text: Hide variations in Block Inspector (hack). (73238)
  • Styles Tab: Fix bug where contentOnly experiment forced it to always be displayed. (73534)
  • Disable Term Query blocks in Widgets Editor. (73449)
  • Comments Count and Comments Link: Ensures that the preview is displayed correctly in the StyleBook. (73213)

Global Styles

  • Preview Styles: Prevent leaked shadow due to blur. (73545)
  • Update generateGlobalStyles function to include variationStyles option. (73535)
  • Variations global styles: Replace useSetting with useStyle for fetching block variations. (73533)
  • Global Styles: Fix media upload permission check. (73503)
  • WP_Theme_JSON_Gutenberg: Preserve valid non-preset settings when KSES filters are active. (73452)

Components

  • Fix: Keep Guide close button visible on hover. (73220)
  • Normalize displayed dates to UTC time for DateTimePicker. (73444)
  • Try fixing full-screen modal height so contents can scroll. (73150)

Block bindings

  • Error handling for external sources. (72585)
  • Fix coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress./term-data source bug, refactor, 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. (73366)
  • Move computation of sources into dedicated useSelect. (72974)

Interactivity API

  • iAPI: Fix using getServerContext in derived state getters. (73518)
  • iAPI: Return a deep-clone object from getServerState and getServerContext functions. (73437)

Collaboration

  • Notes position alignment in HTML. (73046)
  • Notes: Collapse note on blur. (73158)
  • Notes: Fix warning in comment content check. (73198)

Patterns

  • Check for prevent default on event to enable media placeholder button. (73564)
  • contentOnly patterns: Fix lock icon appearing on toolbar when editing a section. (73457)

Block API

  • Block Support: Change block visibility support key. (73432)

Layout

  • Prevent empty contentSize and wideSize values ​​from being saved. (73281)

Accessibility

  • Fix a11yAccessibility Accessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) of descriptions and alerts for “Invalidinvalid A resolution on the bug tracker (and generally common in software development, sometimes also notabug) that indicates the ticket is not a bug, is a support request, or is generally invalid.” Nav Items. (73177)

DataViews

  • Add grid keyboard navigation. (72997)
  • Make DataViews table checkbox permanently visible. (73245)

Performance

  • Remove some modal subscriptions when inactive. (73014)
  • Theme: Simplify ramp object by flattening warnings to optional top-level property. (72942)

Experiments

  • Add experimental abilities and workflow palette and move abilities API. (72703)
  • Lazy Editor: Fix Media Library loading. (73176)
  • Lazy Editor: Fix script modules loading. (73237)
  • Navigation Route: Add initial list and edit routes. (73259)
  • Refactor: Make WordPress abilities a script module instead of a global. (73364)
  • Routing: Add init modules. (73284)
  • Routing: Add pattern routes. (73317)
  • Routing: Add styles page as a route. (73197)
  • Routing: Add template part route. (73303)
  • Routing: Extract route package. (73191)
  • Routing: Support canvas clicks. (73348)
  • Styles Route: Allow switching between stylebook and homepage. (73253)

Patterns

  • ContentOnly Patterns experiment: Add content only inspector fields. (71730)
  • ContentOnly mode: Exclude template parts for now. (73332)
  • Routes: Small fixes to the pattern list and template part list routes. (73520)

Templates API

  • Add template route to the new site editor infrastructure. (73525)
  • Template Route: Add the ‘add new template’ button. (73542)
  • Template Activation: Rename gutenberg_get_block_template. (73582)
  • Template Activation: Use string IDs when experiment is off. (73585)

Block Library

  • Disable TinyMCE: Polish refresh message. (73485)
  • contentOnly Patterns experiment: Add content only support again for template parts. (73419)

DataViews

  • Routing: Preload routes properly. (73384)
  • Add experiment flag for Customizable Navigation Overlays. (73356)

Media

  • Reuse mediaUpload filter for new media modal by wrapping it in a class component. (73225)

Documentation

  • DataViews: Combine duplicate “enhancements” grouping in changelog. (73227)
  • DataViews: Update documentation for layout prop. (73470)
  • Docs: Use consistent content formatting for experimental packages. (73212)
  • Field API docs: Improve Edit. (73202)
  • Field API: Document missing props. (73515)
  • Field API: Update documentation for operators. (73523)
  • Field API: Update documentation to better communicate field types. (73349)
  • Update Gutenberg Version for WordPress 6.9. (72925)
  • Update dataviews readme with new pickerTable layout. (73372)
  • Update undestanding-global-state-local-context-and-derived-state.md. (73233)

Code Quality

  • Asset Loader: Load all scripts in body (footer). (73584)
  • Core Data: Update Attachment type to more accurately reflect fields in media API responses. (73223)

Patterns

  • Content only block experiment: Blocks provide the form. (73479)
  • ContentOnlyControls: Refactor to use DataForm. (73374)
  • Resolve_pattern_blocks sync with Core 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.. (73570)

DataViews

  • Field API: Simplify field normalization. (73387)
  • Field API: Simplify normalization. (73546)
  • Revert “[DataForm]: The ModalContent component doesn’t properly check for fields validity – [#73330]”. (73367)

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.

  • Command Palette: 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. changes in core. (73567)

Components

  • Storybook: Replace implicit actions with explicit ones. (73502)

Block bindings

  • Make core/post-data source code more semantic. (73394)

Collaboration

  • Notes: Ignore flood and duplicate checks. (73232)

Block Library

  • Deprecate Pullquote Block. (73228)

Tools

  • Project: Add CODEOWNERS entries for ui and theme packages. (73369)
  • Update codeowners for packages/dataviews. (73204)

Build Tooling

  • Add missing package dependencies. (73258)
  • Build: Fix CSS rebuilds. (73380)
  • Build: Make pages building using the routing infrastructure independent of Gutenberg. (73379)
  • Build: Moment-timezone shouldn’t be a mandatory dependency. (73352)
  • Exclude JSJS JavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors./TS test files from build. (73495)
  • Framework: Sync lockfile changes under Node.js v24 build. (73314)
  • Scripts: Improve handling of check-licenses for optional dependencies. (73026)

Testing

  • Block Bindings: Add unit test coverage for core/post-data source. (73055)
  • Block Bindings: Remove end-to-end test theme. (73209)
  • Unit testing: Allow Composer to auto-detect PHP version. (73358)
  • end-to-end Tests: Remove movie CPTs after block bindings tests. (73235)
  • end-to-end Tests: Skip flaky list view test. (73234)

Various

  • UIUI User interface: Remove shorthand prop options from Box component. (73529)

Collaboration

  • Notes: Improve delete confirm message for replies. (73173)
  • Update button label from “Add new note” to “Add new reply”. (73189)

Templates API

  • Template activation: Move php files. (73402)

Block Library

  • contentOnly patterns experiment: Make the Inspector fields key a private API. (73376)

Patterns

Double-click on pattern to edit pattern. (73268)

First-time contributors

The following PRs were merged by first-time contributors:

  • @PaulAsaf2: Update undestanding-global-state-local-context-and-derived-state.md. (73233)
  • @RoyHridoy: Fix: Keep Guide close button visible on hover. (73220)
  • @triple0t: Dataforms: Update Email Control component to use envelope icon instead of atSymbol. (73184)
  • @xristos3490: Fix alignment when viewing a DataView with table layout and non-default column alignment. (73398)

Contributors

The following contributors merged PRs in this release:

@aaronrobertshaw @adamsilverstein @aduth @andrewserong @annezazu @anomiex @audrasjb @bph @cbravobernal @DAreRodz @ellatrix @felixarntz @getdave @gigitux @harshbhonsle @hbhalodia @jameskoster @jasmussen @jeryj @jorgefilipecosta @jsnajdr @karthick-murugan @luisherranz @MaggieCabrera @Mamaduka @mcsf @mikachan @mikejolley @mtias @ntsekouras @oandregal @ockham @PaulAsaf2 @priethor @ramonjd @RoyHridoy @ryanwelcher @scruffian @senadir @shimotmk @simison @SirLouen @t-hamano @talldan @tellthemachines @triple0t @tyxla @xristos3490 @youknowriad

Props to @annezazu and @matveb for reviewing this post, and @joen for the visual assets!

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

annezazu 2:00 pm on July 28, 2025
Tags: ,   

Roadmap to 6.9

WordPress 6.9 is scheduled to be released on December 2nd, 2025. Though initially only one release seemed feasible for 2025, project leadership reevaluated this plan when contributor capacity increased in recent months and decided an additional release was achievable. The release turns its attention to evolving the Site Editor with a simplified editing mode and more intuitive template management, enabling collaborative content creation through 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.-level commenting, extending developer 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). with updates to the Interactivity 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. and the introduction of the Abilities API, and improving performance with faster page transitions and smarter resource handling. Of note, there will not be a new default theme in 6.9, a decision shaped by the pace of this release and the maturity of block themes over recent years.

As always, what’s shared here is being actively pursued, but doesn’t necessarily mean each will make it into the final release of WordPress 6.9.

Table of Contents

Evolving the Site Editor 

The Site Editor encompasses the interface and tools used to customize templates, pages, and styles across an entire site. Various key areas of improvements are slated for this release.

Simplified site editing

Now that the site editing experience has matured in 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)., the focus is turning towards adding a simplified site editing option that centers content editing over the full suite of design tooling, with the ability to switch back and forth between the two depending on what edits one wants to make. This option preserves the full power of advanced styling tools when needed, yet empowers users who simply want to update copy or imagery to do so without distraction or overwhelm. By separating these experiences, it’s clearer and more intuitive when stepping into the deeper design toolkit available.

Follow this tracking issue for more details.

Expanded template management

Template management is being overhauled to make templates more flexible and intuitive, solving some longstanding points of feedback. This includes adding support for multiple templates per slug, with the ability to activate or deactivate them for easy switching between theme and custom templates. Users will be able to draft new templates before publishing and activating them, preserve custom templates when switching themes, and take advantage of simplified management through standard 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/ endpoints.

Follow this pull request for more details. 

Ability to hide blocks

This feature aims to provide a way for users to temporarily hide blocks from the frontend while keeping them editable in the backend. It’s perfect for staging content, trying out alternate designs, or holding space for sections that aren’t quite ready. By supporting non-destructive workflows, it encourages experimentation and smoother collaboration. It also lays the groundwork for future improvements with the ability to hide blocks based on screen size.

Follow this issue for more details.

Refining content creation 

WordPress, from its earliest days, has enabled millions of people to share countless perspectives in their own words and in their own way. Relentlessly refining how it feels to write with WordPress to make it as unobtrusive and powerful as possible remains a key focus. This includes a more direct and obvious drag and drop of key blocks, expanded block transforms, keyboard improvements, numerous block settings updated to a more modern and unified UIUI User interface, and more. 

New blocks

To expand customization options and align with modern design standards, several new blocks are planned for this release, including the Accordion block, Terms Query block, Stretchy Type block, Icon block, and potentially more. Each of these blocks will be explored with the goal of enhancing expressiveness and providing stronger defaults, so that building modern websites feels more seamless and flexible.

Follow this tracking issue for more details.

Block level commenting

There are multiple workflows that rely on asynchronous collaboration, like a newsroom needing an editor to review a post for a writer before publishing. Adding the ability to leave comments at a block level begins the steps towards a truly collaborative experience within WordPress. This work includes adding, viewing, and resolving comments in a way that feels truly baked into the WordPress writing experience. The scope for this release will focus on block level commenting. 

View of the block editor with an Image block selected and a comment visible in the right sidebar.

Follow this iteration issue for more details. 

Command Palette everywhere

6.9 aims to bring the Command Palette into all parts of the WordPress experience, offering a quick and universal way to navigate all parts of your site and take different actions. Expanding the scope of where the Command Palette can be used also lays the groundwork for future AI integration points, like with the Abilities API. 

Command palette in focus with the WordPress dashboard in the background.

Follow this issue for more details.

Developer updates

Updates to DataViews Package

For both the DataViews and DataForm components, updates are planned to make them more powerful and enable new use cases. This includes the following:

  • New field types (ex: media, boolean, email and array field type definitions).
  • New 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. operators (ex: lessThan, greaterThan, lessThanOrEqual, greaterThanOrEqual, contains, notContains, startsWith, between, on, notOn, before, after, inThePast, over, beforeInc, and afterInc.).

Follow this iteration issue for more details.

Introducing the Abilities API

This new API provides a registry of callable functions with defined descriptions, inputs, and outputs. It’s designed to make WordPress functionality accessible to AI systems particularly and developers alike through a unified registry of resources and tools. 

Follow this overview issue and read this Make AI post for more details.

Updates to Interactivity API

WordPress 6.9 will introduce a new algorithm for the client-side navigation of the Interactivity API that replaces not only the HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. but also the CSSCSS Cascading Style Sheets., and loads any 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 required by blocks appearing on the new page. This new algorithm will address prior limitations and enable experiences not possible today, like:

  • Support for client-side comment form submissions.
  • Support for showing “No results” blocks in instant search or filters.
  • Supporting the Post Content block within regions.
  • Support for conditional CSS/JSJS JavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. (blocks that enqueue different CSS/JS assets based on attributes/content).

It also paves the way for an opt-in full-page client-side navigation feature in the future.

Follow this iteration issue for more details. 

Updates to Block Bindings

The Block Bindings API connects coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. blocks to dynamic data sources, like custom fields or external APIs, without needing to create custom blocks. Building on this current foundation, 6.9 aims to evolve the current API by adding support for more blocks, improving the UI, and making the API more extensibleExtensible This is the ability to add additional functionality to the code. Plugins extend the WordPress core software.. 

Follow this iteration issue for more details.

Updates to HTML API

The HTML API provides a set of tools for developers to reliably and efficiently interact with HTML within the WordPress environment. Work is underway to greatly increase the speed of the HTML processor, cover support for more edge cases, introduce safe composable HTML templating, and develop block attribute sourcing.

Follow this iteration issue for more details. 

Performance improvements

Planned performance improvements include improving Data Views performance by supporting partial entity fetching and smart field resolution, adding the ability to handle “fetchpriority” to ES Modules and Import Maps, standardizing output buffering so developers can hook into a unified filter and manipulate the entire rendered HTML after it’s generated but before it’s sent to the browser (e.g. for page caches and performance optimizations), implementing instant page navigations from browser history via bfcache even when pages are flagged with “nocache” such as when users are logged in (punted due to Chromium 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.), and stylesheet improvements around minification and inlining. 

Early previews alongside 6.9

While not explicitly a part of 6.9, a few different major initiatives are planned for launch alongside the release either as canonical plugins or as experimental features 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/.

New WordPress Adminadmin (and super admin) experience 

A modular and extensible redesign of the WordPress admin is being mapped out, with a strong emphasis on flexibility, customization, and a coherent user experience. Early exploration centers on defining foundational primitives, building blocks that separate structure from presentation to support broad reusability across admin surfaces.

Follow this overview issue for more details.

MCP Adapter

Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to LLMs. In WordPress, the MCP Adapter (GitHub) implements this open standard, exposing Abilities to AI assistants, while also connecting to other MCP servers. MCP’s applications are transformative for various users. Content creators can manage their WordPress sites conversationally, while developers can automate complex workflows across systems. Agencies can build sophisticated integrations, from content migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. to performance optimization. Around the 6.9 release, a canonical pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. is expected to be launched. 

Read this Make AI post for more details.

PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher AI Client

The PHP AI Client SDK (GitHub) aims to offer a unified, provider‑agnostic interface for integrating AI into WordPress and other PHP projects. It centralizes credential management so site admins configure their preferred AI service in one place, enabling any AI‑enabled plugin to work seamlessly without requiring duplicate setup. Developers benefit from a ready‑made framework that handles model selection, streaming, multimodal capabilities, error handling, and provider quirks—letting them focus on features rather than rebuilding the same foundational pieces. It’s modular too: a core PHP package supports broad use cases, while a WordPress‑specific add‑on delivers admin UI, REST API 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 Abilities API integration, all poised to adapt as AI evolves. This shared infrastructure lets WordPress plugins and other PHP projects integrate AI capabilities rapidly and flexibly. Around the 6.9 release, a canonical plugin is expected to be launched. 

Read this Make AI post for more details.

Find something missing? Want to help?

If you have something you’re working on that you don’t see reflected in this post, please share a comment below so we can all be aware! If you’re reading this and want to help, a great place to start is by looking through each issue associated with each area or by diving into the Polish board where a curated set of issues are in place that anyone can jump in on.

Thank you to @desrosj @luisherranz @fcoveram @jameskoster @youknowriad @matveb @jeffpaul @oandregal @westonruter for reviews and contributions.

Changelog

The following notes the date and type of change made to this post in order to keep it as accurate as possible ahead of the release.

September 4th, 2025:

  • Added in a “New blocks” section under “Refining Content Creation”.
  • Removed “An initial experimental version is planned in the Gutenberg plugin, where contributors can opt-in and offer feedback” under “New WordPress Admin experience” as that’s no longer planned.

#6-9, #release-roadmap

Mary Hubbard 4:43 pm on April 4, 2025
Tags: ,   

Dotorg Core Committers Check In

On March 27, 2025 nearly 30 coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. committers, project leaders, and core team members gathered to discuss the release cadence and if there is a need to change it. The impetus for this conversation is due to organizations cutting back on the number of hours they are donating towards contributing to WordPress.

Attendees: @matt, @desrosj, @jorbin, @timothyblynjacobs, @davidbaumwald, @jjj, @clorith, @jeffpaul, @joemcgill, @kadamwhite, @fabiankaegy, @4thhubbard, @adamsilverstein, @swissspidy, @whyisjake, @spacedmonkey, @eidolonnight, @matveb, @audrasjb, @mamaduka, @karmatosed, @sergeybiryukov, @westonruter, @ryelle, @flixos90, @williampatton, @poena, @johnbillion, @joedolson.

An assessment of core team activity shows the number of both 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/ tickets and Core TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. tickets remaining nearly flat over the last 6 months. However, the volume of new features being worked on inside the Gutenberg repository has plunged since January. In light of this information, the discussion focused on if the current release cadence should be reduced.

Numerous pros and cons were discussed.

The pros included:

  • Aligns WordPress with the release cadence that is becoming en vogue amongst some large organizations such as eBay and Airbnb
  • Can use this change to signal an intentional reset and focus on quality
  • Allows for greater focus on canonical plugins and on individual component roadmaps, which can be iterated on and shipped independent of major releases.
  • Slowing down helps allow for documentation and any needed infrastructure improvements.
  • Allow for each release to contain larger features and enhancements and not be “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. fix only” releases.
  • Reduces the workload and coordination overhead for contributors, systems team, and release leads.
  • Allows for work to further automate release processes, making future releases quicker and less manual.

The cons and risks discussed included:

  • Fewer releases can slow down user feedback loops for new features.
  • Slower cadence can lead to contributors not being able to see their work published or feel recognized as quickly.
  • Makes it harder for changes that we may want to roll out over multiple releases
  • Harder to make changes such as coding standard updates that can lead to a release 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 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. changing.
  • Potential for anxiety over larger releases from users, site owners, and anyone else applying updates.
  • Potentially harder for organizations to justify time and resources for sponsored contributors.
  • Less visible momentum towards the project’s overall goals, possibly perceiving the project as stale.
  • Care needs to be taken to preserve the culture and trust built in auto-updates that the project has worked hard to build over the last decade.

Proposed Focus Areas

The conversation moved to discussing where contributors could effectively focus their efforts in the project should the release schedule shift to just one release per year.

Canonical Plugins

Community maintained canonical plugins such as Preferred languages, 2FA, and the Performance Team’s suite of plugins are a great way to ship features and iterate without requiring a major releasemajor release A release, identified by the first two numbers (3.6), which is the focus of a full release cycle and feature development. WordPress uses decimaling count for major release versions, so 2.8, 2.9, 3.0, and 3.1 are sequential and comparable in scope. of WordPress itself. There were two main improvements that need to be addressed to make them more effective.

First is the need for better means to collect user feedback. Active installs is currently the only metric available, but doesn’t provide enough value. Does a user actually interact with the feature? In what ways? Do they feel it’s valuable? Feedback is mainly received from users when something breaks. There was agreement to explore telemetry and ways to establish meaningful feedback loops within canonical plugins.

The second improvement needed is promotion. It’s often not widely known that canonical plugins exist or that they are officially maintained. Different ways to raise awareness about canonical plugins will be explored, including posts on 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/ News blogblog (versus network, site), mentioning them in presentations such as State of the WordState of the Word This is the annual report given by Matt Mullenweg, founder of WordPress at WordCamp US. It looks at what we’ve done, what we’re doing, and the future of WordPress. https://wordpress.tv/tag/state-of-the-word/., and possibly the currently barren Tools page in the WordPress adminadmin (and super admin).

Backlog Management

  • Going through the backlog of ~13,000 total tickets on Trac and Gutenberg’s 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/ repository is something that can be done independent of major releases.
  • The majority of bugfixes can be shipped in minor releases.
  • ‘maybelater' resolution exists for a reason and should be used more often. Discussion can always continue on closed tickets.
  • A large backlog can damage the perception of project quality and maintainability.
  • All numbers are just numbers in isolation. They need to be considered in context with surrounding factors.

Miscellaneous

  • Look for ways to encourage wider testing of betaBeta A pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process./RCrelease candidate One of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). releases, and even nightly builds through the initiatives like the Host Tests, and educating developers of the possible advantages of continually using trunk for testing.
  • Reevaluate the Core SVNSVN Subversion, the popular version control system (VCS) by the Apache project, used by WordPress to manage changes to its codebase./Gutenberg repository setup to find ways to streamline the release process.
  • With overall fewer features being built in the Gutenberg repository, shifting 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.’s release cadence to once a month may make sense. Though the current cadence is manageable, mostly automated, keeping this consistent is preferable if volume allows.
  • Encourage component maintainers to be more active by clarifying the responsibilities and expectations of volunteering in that capacity.
  • Release squads should primarily coordinate, encouraging broader autonomy and participation by components and various Make WordPress teams.
  • For 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), clarify the differences between mandatory compliance (WCAGWCAG WCAG is an acronym for Web Content Accessibility Guidelines. These guidelines are helping make sure the internet is accessible to all people no matter how they would need to access the internet (screen-reader, keyboard only, etc) https://www.w3.org/TR/WCAG21/.) and what non-blocking aspirational best practices are.
  • Explore faster release models once shortcomings in tooling are addressed.
  • Get better at involving contributors with non-development skill sets (e.g., design, testing, product) in more ways.

Summary

In light of these discussions, the current plans of project leadership are for 6.8 (due this month) to be the final major release of 2025. Gutenberg releases will continue on the current every two week schedule and minor releases will take place as needed throughout the year. Minor releases will continue and happen as necessary with a more relaxed barrier for inclusion of enhancements, but the “no new files in minor releases” rule should continue to be followed.

Based on this productive conversation, a decision was made to organize these calls on an ongoing basis starting with a quarterly cadence. I will ensure to schedule accordingly.

Props to @jorbin and @desrosj for collecting the summary and writing this post.

#core-committer-meetings, #core-committers

annezazu 9:36 pm on November 21, 2024
Tags: ,   

Update on Phase 3: Collaboration efforts

Over the last year, Phase 3 of the GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ roadmap has begun to take form and with it comes a need for an update around what’s been done, how to follow along, and what to expect going forward. This post seeks to provide answers at a high level view of these questions. As a reminder Phase 3 is centered around fostering seamless collaboration, tying together the user experience, and streamlining the content management flows to improve the way creators and teams work together within WordPress. As work progresses, feedback is needed and welcomed to ensure broader adoption.

Real-time collaboration

Over the last few months, Kevin Jahns, the author of Yjs, a popular framework for building collaborative applications has been sponsored by Automattic to work on real-time collaboration, after an initial experiment landed. He kicked off his efforts with some research and dialogue in this discussion issue. More recently, he’s pulled together some prototypes ahead of sharing a full proposal for how to proceed. Right now, consider this work as being in a strong experimental stage without a final approach. The next step is to get the initial approach into a PR for folks to give feedback on and discuss openly. 

Below is a demo showing syncing content only relying on 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. APIs with the autosave interval set to 3 seconds. Because it relies on HTTP APIs, this demo would work on all WordPress instances:

Going a step further, you can see more demos in a recent update including adding y-webrtc into the experience to show how real time collaboration would work for users who can establish a peer-to-peer WebRTC connection.

Follow along in this dedicated GitHub issue and/or in the #feature-realtime-collaboration 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/ channel.

Async collaboration: In-line comments

An initial experiment for block-level inline comments landed with Gutenberg 19.6, breaking ground on the first of many async collaboration upgrades. At this point, another iteration on this initial feature is already planned and underway to refine the current experience further. If you’d like to help test and shape the feature further, stay tuned for a dedicated call for testing or start testing today with this WordPress Playground instance and open issues in the Gutenberg 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/ repository. The aim is to get early feedback and quickly iterate in order to land this new feature in an upcoming major WordPress release. Below is a look at the near term design slated to be shipped next with visuals for adding a comment, leaving a comment, toggling to see resolved comments, and the resulting view when looking at resolved comments:

The post editor open to a paragraph block selected and the "more" menu open. The "Add comment" option is highlighted as if to select it and a few comments are visible in the right sidebar.
The post editor open to a paragraph block selected and an in progress comment being written in the right sidebar. Other comments are visible.
The post editor open to a paragraph block selected and the right sidebar visible showing a comments section with a toggle open to select "Show resolved" or "Show mine". Show resolved is highlighted.
The post editor open to a paragraph block selected and the right sidebar visible showing a comments section with a toggle open to select "Show resolved" or "Show mine". Show resolved is selected and some greyed out resolved comments are visible.

Follow along in this dedicated GitHub issue. 

Adminadmin (and super admin) redesign: DataView & DataForm

DataViews is the foundational component of the initial overall admin design efforts. By design, these views are being built out only in the Site Editor, with a few efforts branching out including an experiment for a new, separate Posts experience using Data Views and an early Media Library powered by Data Views proof of concept.  

As a next step of the initial development of DataViews, the more recent DataForm API was later introduced in Gutenberg 18.8 with the aim to reduce expected duplication to create forms in Data Views. Work has continued progressively from there with DataViews and DataForm components influencing each other’s development. You can view each in their respective Storybook views: DataViews and DataForm.

Both of these components have been created with extensibility at the heart of everything being built! For now, pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. and agency developers can already start using the DataViews component for their WordPress customizations with two different Developer Blogblog (versus network, site) tutorials to get you started: Using Data Views to display and interact with data in plugins and Actions from Data Views: Adding images to the Media Library. If you want to go on a deeper dive, watch a recent hallway hangout that goes through both of these components with folks actively working on them. Expect a continual focus on extensibility as these components evolve. Below is a look at how DataViews comes together with the DataForm work with an easy option to quick edit within one’s pages:

Follow along in this dedicated DataViews component issue and this DataForm component issue. For early design work in this area and beyond, check out the biweekly design updates.

Thanks to @priethor @youknowriad @4thhubbard @matveb for reviewing this post and for @joen and @jameskoster for the design assets.

#gutenberg, #phase-3

Jonathan Desrosiers 3:46 pm on July 22, 2024
Tags:   

Aligning Committer-Level Access Across the Code Base

At WCEU 2024 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/, several CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Committers and project leaders had an impromptu discussion about how to unify the permissions and 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). for the project’s 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.-level contributors between the two code bases (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/ on GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged by the repository owner. https://github.com/ and Core in SVNSVN Subversion, the popular version control system (VCS) by the Apache project, used by WordPress to manage changes to its codebase.).

Present for the discussion: @desrosj, @jorbin, @youknowriad, @ellatrix, @bernhard-reiter, @chanthaboune, @matveb, @priethor, @gziolo.

Gutenberg is Core, and Core is Gutenberg. Ultimately, everyone works on the same software to achieve the project’s goals. Where that work occurs is not important. Suppose you are a contributor entrusted with privileged access to one part of the code base. In that case, there’s no reason why you should not have equivalent access in another location just because the tooling is different. Committers are trusted to make decisions, including the decision that they are not the best person to make specific decisions. Disparity in access leads to unnecessary bottlenecks and confusion around who can tackle specific tasks in specific areas.

As a first step to address this, the WordPress Core team on GitHub (consisting of all contributors with SVN commit access) has been given write access and the ability to merge pull requests to the Gutenberg repo. All Core Committers previously had this access, but this changed at some point, seemingly due to changes on GitHub.

Here are the rest of the proposed changes:

  • The Gutenberg Core Team on GitHub becomes a subset of the Core Committer list in SVN. To be on the Gutenberg Core Team, you must be a committer.
  • Going forward, the committer nomination process is required for any contributors to be added to the Gutenberg Core Team. To reiterate the current approval process: a public nomination in the #core-committers channel to field feedback from the community and a review/approval by @matt are required to grant anyone commit access (they would now receive commit access to SVN at the same time).
  • Bug GardenersBug Gardener A contributor who has been given advanced privileges in Trac. in TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. and the Gutenberg Team in GitHub become synonymous. Members of each group can request access to the other if it helps them contribute more effectively. Though members of the Gutenberg Team have write access on GitHub, no equivalent write access is given in SVN. This will be considered something similar to what was previously known as “guest commit.”

To truly align these two groups, everyone present at this discussion collectively nominated all Gutenberg Core Team members without SVN commit access: @0mirka00, @aaronrobertshaw, @andraganescu, @andrewserong, @aristath, @cbravobernal, @czapla, @get_dave, @glendaviesnz, @jameskoster, @joen, @kevin940726, @luisherranz, @mciampini, @mikachan, @nerrad, @ntsekouras, @ramonopoly, @richtabor, @scruffian, @talldanwp, @tyxla, @wildworks.

@matt approved these nominations after allowing 3 weeks for any feedback. Please join us in congratulating these contributors!

Over the next few weeks, these new committers will be on boarded and paired up with a current committer willing to be their buddy for their first few commits. Any of these nominees are also free to receive this access and not use it, or to decline the additional access should they feel it’s something they don’t want or won’t use.

If you’re one of the nominees, here are some required reading materials from the Core Handbook:

The process of adding these new committers will be tracked in Meta Trac in ticket 7722.

Props @jorbin, @cbringmann, @chanthaboune, @ellatrix, and @youknowriad for prepublish review.

#core-committers

Daniel Richards 6:08 am on June 20, 2024
Tags: , , ,   

What’s new in Gutenberg 18.6

“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 18.6 has been released and is available for download!

51 contributors have shipped 157 pull requests in this release, and a big welcome to four new contributors. With WordPress 6.6 rapidly approaching, many contributors are focusing on bugbug A bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. fixes, with this release including a total of 62 fixes. There are still some great features being worked on, and this release introduces the new background image feature to several blocks.

Thanks to everyone involved in this release! 👏

  1. Background image support for Quote, Verse and Post Content blocks
  2. DataViews: Extensibility APIs
  3. Changelog
  4. First-time contributors
  5. Contributors

Background image support for Quote, Verse and Post Content blocks

Screenshot of the quote block with a background image
Screenshot of the verse block with a background image

Freshen up the look of the quote, verse, and post content blocks using the new background image feature.

Previously, options for background images were limited to container blocks like the Cover and Group blocks, but with the feature now supported across several blocks, it’s easier for users to attain the look they want without nesting blocks.

Follow all the work on background images in the GitHub tracking issue.

DataViews: Extensibilty APIs

Very early work on extensibility for DataViews was shipped in this release.

‘DataViews’ is the component that powers the post listing views available in the Site Editor, and in the future will become an important part of the new adminadmin (and super admin) design project.

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. being explored will allow the registration of actions for different ‘entities’ (post types and other types of data represented by the listings). Right now, the API is private to the Gutenberg PluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. and will undergo further development and testing before being made public for third parties.

Find out more in the GitHub pull request for the feature, and read the recent update on DataViews for more background on the work.

Changelog

Enhancements

Design Tools

  • Post content 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.: Add background image and padding support. (62499)
  • Quote blocks: Add background image and minimum height support. (62497)
  • Verse block: Add background image and minimum height support. (62498)

Block Library

  • Post Date & Comment Date: Add relative date format. (62298)
  • Replace “Add new post” link text with more meaningful Label (v2). (62277)

Block Editor

  • LinkControl: Refined the display of the link preview title and URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org when both are same. (61819)
  • Update URL to uppercase. (62231)

Block bindings

  • Change bindings panel title, add description. (62489)

Site Editor

  • Unify DataViews 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. Title & Subtitle. (62429)
  • Template inspector: Small visual adjustments. (62537)

Document Settings

  • FlatTermSelector: Update the term suggestion limit. (62359)

Global Styles

  • Update custom CSSCSS Cascading Style Sheets. handling to be consistent with block global styles. (62357)

Post Editor

  • Try: Re-enable ReactReact React is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org StrictMode. (61943)

New APIs

Extensibility

  • DataViews: Bootstrap Actions Extensibility API. (62052)

Bug Fixes

  • CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Data: Fix errors when the entities list doesn’t contain configuration key. (62346)
  • Data Views: Bulk toolbar covering other clickable elements. (62333)
  • Fix: Omit default parameters from pages, template parts, and patterns. (62372)
  • Fix: Show homepage link on frontpage instead of the slug. (62279)
  • Fix: Unquoted file argument in declaration check script. (62482)
  • List: Fix pasting. (62428)
  • Revert CSS removal for interface footer breadcrumbs. (62309)
  • Revert test data for WithSlug variation. (62579)
  • Scripts: Pin the wordpress/scripts version to a version supported by 6.5. (62234)
  • Site Editor Hub: Simplify. (61579)
  • Style Book: Allow activation when the canvas mode is “view”. (62212)
  • Top toolbar: Fix half a pixel artifacting of the bottom border. (62225)
  • Try: Contextual frame bg color to avoid artifacting. (62223)
  • Try: Fix mover positioning. (62226)
  • Update instances of text-wrap: Pretty to fall back to balance. (62233)
  • MediaUpload: Remove dialog markup on close. (62168)

Global Styles

  • Add default-spacing-sizes and default-font-sizes options for classic themes. (62252)
  • Add custom CSS for block style variations. (62526)
  • Color Variations: Use Grid rather than VStack. (62445)
  • Don’t apply the background and text colors to typography previews. (62578)
  • Fix UIUI User interface appearing on blocks that don’t support text alignment. (62376)
  • Fix UI order for 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. spacing sizes. (62199)
  • Fix registration of theme style variation defined block styles. (62495)
  • Only use single property variations as color/type presets. (62469)
  • Section Styles: Register block style variations on init. (62461)
  • Section styles: Consolidate variation name. (62550)
  • Section styles: Support i18ni18n Internationalization, or the act of writing and preparing code to be fully translatable into other languages. Also see localization. Often written with a lowercase i so it is not confused with a lowercase L or the numeral 1. Often an acquired skill. for variations declared in theme.json or theme style variations. (62552)
  • Sort spacing sizes when all slugs begin numerically. (62567)

Site Editor

  • Change Site Editor to Edit site. (62501)
  • Fix “insert before/after” not showing for blocks in site editor. (62530)
  • Site Export: Ensure that the export endpoint uses Gutenberg theme classes. (61561)
  • Update old document URLs to new ones. (62206)
  • Update 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. title + icon + site title alignment. (62191)

Block Editor

  • Inserter: Allow focus to move to the toggle when opening the inserter. (62513)
  • Inserter: Return the same items when the state and parameters don’t change. (62263)
  • Remove ‘rootClientId’ argument for block lock selectors. (62547)
  • Update fetchLinkSuggestions to sort results by relevancy. (62397)

Block Library

  • Fixed Media Text Block Issue : When crop image to fill is enabled, the image in nested media & text blocks does not show. (62182)
  • Media & Text block: Fix nested Media & Text block media position issue with increased CSS specificity. (62184)
  • Query: Adjust the position of sticky search field in Patterns modal. (62370)

Post Editor

  • Editor: Avoid remounts of DocumentBar. (62214)
  • Editor: Make 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. more prominent. (62323)
  • Editor: Refine availability of rename post action. (62248)
  • Fix move CONTENT_ONLY_BLOCKS into component body to ensure the editor.postContentBlockTypes 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. gets called whenever the values are used. (62292)

Components

  • Ensure that openref is defined before accessing to .current. (62508)
  • Fix: Update styles for checkbox and radio controls. (61696)
  • Tabs: Prevent accidental overflow in indicator. (61979)

List View

  • Fix home and end key behaviour in very long lists. (62312)
  • Respect default shortcuts in modals. (62479)
  • Show context menu for content-only blocks in posts. (62354)

Block bindings

  • Fix applying bindings or pattern overrides to button blocks with empty text. (62220)
  • Fix site editor breaking when user selects bound and non-bound blocks at the same time. (62268)
  • Revert changes to bindings replacement logic to not use regex. (62355)

Synced Patterns

  • Block Bindings / Pattern Overrides: Prevent normal attribute updates when a __default binding exists. (62471)
  • Fix showing double icons for connected blocks in pattern editor. (62317)

Data Views

  • DataViews: Fix unnecessary horizontal scrollbar in list layout. (62448)
  • Page creation and duplication: Decode HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. entities in success notices. (62313)

Patterns

  • Fix increasingly big canvas in the post editor when editing patterns. (62360)
  • i18n: Patterns: Disambiguate singular & plural uses of ‘Synced’ & ‘Unsynced’. (62375)

Data Layer

  • Data: Add error handle to the ‘registry.batch’ method. (62322)

Block Variations

  • Compare objects based on given properties. (62272)

Block Styles

  • Remove core block style variations filters and action. (62090)

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)

  • Add lint rule for inaccessible disabled Button. (62080)
  • Placeholders: Fix contrast. (62416)

Global Styles

  • Display tooltips for pagination buttons on styles revision. (62395)

Site Editor

  • Make edit site pagination buttons accessibly disabled. (62267)

Performance

  • reporter: Print the stdout/stderr from the worker. (62316)

Block bindings

  • Only run block bindings Gutenberg logic for sites using WordPress versions below 6.5. (62363)

Interactivity API

  • Use data-wp-on-async directives in core blocks when handler does not need synchronous access to event. (62160)

Experiments

Posts/Tags/Categories Screen

  • Bootstrap the dashboard layout. (62409)
  • Posts Dashboard: Add a new experimental empty page. (62406)

Documentation

  • Add @global PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher documentation. (60539)
  • Add documentation for PostSticky and PostStickyCheck component. (62100)
  • Add documentation for WordCount component. (62217)
  • Added documentation for PostTrash & PostTrashCheck TimeToRead TextEditorGlobalKeyboardShortcuts PostPublishButtonLabel Component. (62116)
  • Better changelogs for the JSX transform upgrade. (62265)
  • Corrected @SInCE Order in Php documentation. (61992)
  • Docs: Explicitly mention new behavior coming in WP 6.6 for block variations. (62399)
  • EntitiesSavedStates editor component. (62377)
  • Fix @since tagtag A directory in Subversion. WordPress uses tags to store a single snapshot of a version (3.6, 3.6.1, etc.), the common convention of tags in version control systems. (Not to be confused with post tags.) in docblockdocblock (phpdoc, xref, inline docs) in WP_Theme_JSON_Data_Gutenberg. (62425)
  • Fix: Invalidinvalid A resolution on the bug tracker (and generally common in software development, sometimes also notabug) that indicates the ticket is not a bug, is a support request, or is generally invalid. link on explanations documentation. (62487)
  • Fixing minor syntax in DataView example code. (62560)
  • Interactivity API template create block: Removed warning for generated README from template. (62324)
  • PostPublishButton, PostPublishButtonLabel editor components. (62379)
  • PostPublishPanel editor component. (62380)
  • PostSwitchToDraftButton editor component. (62381)
  • PostSyncStatus editor component. (62382)
  • PostTaxonomies, PostTaxonomiesCheck, PostTaxonomiesFlatTermSelector, PostTaxonomiesPanel related editor components. (62384)
  • Several typo correction in documentations. (62433)
  • TableOfContents editor component. (62385)
  • ThemeSupportCheck editor component. (62387)
  • Update React API reference links in wordpress/element reference-guides. (62475)
  • Update: Slotfill documentation samples (links, code, and rephrase). (62271)
  • UseEntitiesSavedStatesIsDirty editor component. (62388)
  • block.json schema: Add supports.splitting field. (62209)

Code Quality

  • Add support for local keyframes through a PostCSS plugin. (62476)
  • Block style variation: Rename hook. (62464)
  • Chore: Simplify a padding style on global styles. (62291)
  • Convert autop package to TS. (62583)
  • Convert blob package to TS. (62569)
  • Convert escape-html package to TS. (62586)
  • Convert token-list package to TypeScript. (62584)
  • Convert warning package to TS. (62557)
  • Editor: Cleanup styles and classnames. (62237)
  • Editor: Deprecate PostSwitchToDraftButton. (62402)
  • Editor: Introduce the Editor component and use it in the site editor. (62274)
  • Fix unintended overwrite of eslint no-restricted-syntax. (62301)
  • Fix: Add network-active to valid options in PluginStatus Type definition. (62450)
  • Fix: Flakey deferred store test. (62571)
  • Fix: Remove unused code from dataviews styles. (62275)
  • Fix: Remove unused typography panel styles. (62295)
  • Fixed : Disambiguate “Cover” translatable string in the context of background-panel.js. (62440)
  • Move the template part menu items to the editor package. (62366)
  • Shortcut Help modal: Remove CSS hack for Internet Explorer 11. (62564)
  • Use stable reference for getEntityActions action. (62536)

Global Styles

  • Global styles code quality refactoring. (62299)
  • Migrate theme.json based on origin. (62305)
  • Send theme object to setUserConfig. (61805)

Synced Patterns

  • Extract the pattern overrides toolbar indicator from the block-editor package. (62514)
  • Remove unused syncDerivedUpdates action. (62229)

Post Editor

  • Editor: Combine selector in provider component. (62407)
  • Editor: Use the Editor component in the post editor. (62339)

Site Editor

  • Remove editor specific classes from shell wrapper. (62389)
  • Remove unused code. (62286)

Icons

  • Fix React warning error for offline icon. (62353)

Data Views

  • Chore: Simplify a padding style on dataviews. (62276)

Block Editor

  • Use border instead of hr for filtered block list separator. (62249)

Block bindings

  • Use preview instead of publishing post in block bindings tests. (62235)

Block API

  • Parser: Update validateBlock to use fixedBlock. (62178)

Tools

Testing

  • Fix flaky Site Editor command center end-to-end test. (62454)
  • Perf Tests: Use backward-compatible locators. (62362)
  • Test using Node.js 22.x. (62341)
  • Try: Fix flaky DataViews end-to-end test. (62413)
  • Update Node version for flaky test reporter. (62401)
  • end-to-end Utils: Add retry mechanism to the REST APIREST API The REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/ discovery. (62331)

Build Tooling

  • Build JSJS JavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. module only in development mode. (62398)
  • Speed up check-build-type-declaration-files. (62538)

wp-env

  • Add JSON Schema for .wp-env.json files. (36276)
  • Add WP_ENV_TESTS_MYSQL_PORT / .wp-env.json .env.tests.mysqlPort option etc. (61057)

Various

  • Update all ConfirmDialogs in the codebase to be size=medium. (62532)

REST API

  • Themes REST API endpoint: Add stylesheet_uri and template_uri fields to the response (WP 6.6). (62211)

First-time contributors

The following PRs were merged by first time contributors:

Contributors

The following contributors merged PRs in this release:

@aaronrobertshaw, @aaronware, @afercia, @ajlende, @akasunil, @amitraj2203, @andrewserong, @BrianHenryIE, @carolinan, @carstingaxion, @cbravobernal, @colorful-tones, @DaniGuardiola, @desrosj, @ellatrix, @fabiankaegy, @geriux, @gigitux, @gziolo, @jameskoster, @jasmussen, @jeryj, @joemcgill, @jorgefilipecosta, @jsnajdr, @juanmaguitar, @kevin940726, @Mamaduka, @mcsf, @mirka, @narenin, @noisysocks, @ntsekouras, @oandregal, @ockham, @ramonjd, @richtabor, @SantosGuillamot, @scruffian, @shail-mehta, @sirreal, @stokesman, @t-hamano, @talldan, @tellthemachines, @tjcafferkey, @up1512001, @vipul0425, @westonruter, @WunderBart, @youknowriad

Props to @jameskoster for the visual assets, @priethor for handling the release candidaterelease candidate One of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). at short notice, @andrewserong, @isabel_brison, @annezazu, and @matveb for help with drafting and proof reading this post.

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