The WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. development team builds WordPress! Follow this site for general updates, status reports, and the occasional code debate. There’s lots of ways to contribute:
Found a bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority.?Create a ticket in the bug tracker.
WordPress 6.4 is the third major releasemajor releaseA release, identified by the first two numbers (3.6), which is the focus of a full release cycle and feature development. WordPress uses decimaling count for major release versions, so 2.8, 2.9, 3.0, and 3.1 are sequential and comparable in scope. of the year that delivers a better user experience to site visitors by improving performance of the coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. software. This version improves server response time by ~4% over version 6.3.2. This, combined with additional frontend optimizations, leads to improvements to Largest Contentful Paint (LCP)—an important Core Web Vital. For example, Twenty Twenty-One (a classic theme) shows an improvement of ~4% for LCP and Twenty Twenty-Three (a blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. theme) shows a ~9% LCP improvement when run on WordPress 6.4 compared with 6.3.2 based on benchmarks conducted by the WordPress Performance team.
This release caps off an ambitious year of work for the Performance Team, with major improvements made in each release. You can read more about those improvements in the performance improvement summary posts for version 6.2 and version 6.3. While version 6.2 focused on server side improvements, and 6.3 focused more on client side improvements, this release was focused on continuing server side improvements while further optimizing and extending the improvements that were made earlier in the year. Meanwhile, the team continued iterating on the tools and methodologies used to measure and report on performance.
Performance highlights for this release
An overview of the performance enhancements in this release is included in the WordPress 6.4 Field Guide and you can read details about the following highlights in their individual dev-note posts:
Previous performance benchmarks reported for each release were taken by @flixos90 (the performance release leadRelease LeadThe community member ultimately responsible for the Release.) on his own computer, using a standardized set of best practices and tools. This release we have attempted to automate the process in order to establish a reproducible methodology that can be used by any contributor using a standard set of tools.
The process for this release uses the compare-wp-performanceGitHubGitHubGitHub 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 be the repository owner. https://github.com/ action, originally developed by @swissspidy, which sets up two standard test sites using wp-env inside of a GitHub worker, takes a set of metrics based on 100 requests, and reports them in the action summary (example). To account for variance between each run, this is done 5 times and the median values are used for reporting purposes.
Revisiting previous releases
Since the testing environment has an important impact on performance benchmarks, we wanted to revisit the previous versions from this year and apply the same methodology for comparison. Each of the following metrics show the percentage the metric either improved (negative numbers) or got worse (positive numbers) between versions.
WordPress 6.2.3 vs 6.1.4
Twenty Twenty-One
LCP: +2.87%
Server Timing -4.21%
Twenty Twenty-Three
LCP: -4.72%
Server Timing -18.15%
WordPress 6.3.2 vs 6.2.3
Twenty Twenty-One
LCP: -10.82%
Server Timing -3.34%
Twenty Twenty-Three
LCP: -14.23%
Server Timing -10.21%
WordPress 6.4.0 vs 6.3.2
Twenty Twenty-One
LCP: -3.95%
Server Timing -4.05%
Twenty Twenty-Three
LCP: -9.06%
Server Timing -4.59%
Detailed data can be found in this spreadsheet, with links to the individual GitHub workflows.
Future improvements
While the methodology used for this release is an improvement over the previous process, there is much room for improvement, including finding ways to stabilize the metrics collected during benchmarks for releases and during development, improving the test content and use cases we test for these benchmarks, testing different configurations and environment characteristics (e.g., PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher versions, persistent object cache, etc.).
Props
Props to @joemcgill for taking the time to write this extensive and detailed post, and @flixos90 for review.
8 years ago, a ticket was created in WordPress, suggesting a PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher autoloader for WordPress CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. classes. In that ticketticketCreated for both bug reports and feature development on the bug tracker., many things were discussed regarding the concept of adding a PHP autoloader in WordPress. That ticket discusses adding an APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. to allow pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party developers to register their own classes, it discusses using Composer, as well as other more nuanced topics of implementing an autoloader in WP.
It is a long thread, but a recommended read for anyone wanting to get some more context and historical data. That initial discussion was derailed several times, so for the purposes of this proposal, a new ticket was created on #60414
Since then, a lot of things have changed – both in PHP and in WordPress. Despite all these changes, WordPress Core still loads most of its codebase on each page load – regardless of whether a file is used or not. That means that WordPress takes more time to load, and at the same time consumes more memory than it should.
The time cost of including these extra files is pretty small (almost negligible), but the memory cost is not – especially for small sites running on shared hosting. By including files that are never used on a page load, we’re forcing servers to keep them in-memory, which is obviously sub-optimal.
Current work
In 2022, work started in a pull request to implement a PHP autoloader for Core classes. In the 20 months since the PR was initially created, it has received feedback, has been polished, and has been tested thoroughly. It has been kept up-to-date with the trunktrunkA directory in Subversion containing the latest development code in preparation for the next major release cycle. If you are running "trunk", then you are on the latest revision. version of WordPress and is ready for production.
Initial tests show an improvement in loading time, CPU resources and memory consumption. On average, the improvements server-side for a new WP site with no plugins installed and using the default theme, are approximately 2-3ms for load-time, 0.5-1.5% for CPU time and 5-7% for memory consumption.
What the proposed implementation does
The implementation in that pull-request was kept simple and minimal:
Introduced a WP_Autoload class.
Added a CONST in the object, containing the classMap for classes & their filenames. A hardcoded classMap was deemed preferable because of legacy reasons. WordPress classes don’t (currently) have namespaces or standardized mapping. By using a hardcoded classMap we can introduce an autoloader, and facilitate future implementations & standardization.
Removed the include/require/include_once/require_once calls for files containing classes throughout the WP codebase
Included external libraries and their respective autoloaders in the Core autoloader.
What the proposed implementation does not do:
It does not introduce an API for plugins
The implementation does not introduce an API to allow plugins/themes to add their own classes to the autoloader. Instead, it only focuses on Core classes, keeping things minimal.
Though adding an API and/or method to allow plugins to add their classes to a centralized autoloader is something we can consider for the future, it is not a requirement for this initial implementation, and it would overcomplicate the initial steps of autoloading Core.
It does not use Composer
Since the Composer vs non-composer autoloader was one of the main points of discussion in the 8-year-old ticket, it’s worth mentioning here, and clarify some points:
Composer is a very mature and safe way to autoload classes. However, this initial implementation does not use it.
This proposal is for a minimally invasive, performance-optimized change. It implements autoloading using a hardcoded classMap. Still, It does take care of all the preliminary work so if it is decided that a Composer autoloader is what we want to do, then switching to that will be a relatively easy task. The current PR has a very narrow focus and serves as the first step towards modernizing the WP codebase.
Composer would allow us to automate generating the autoloader, so if deemed appropriate, we could modify the current proposal to implement that.
Adding an initial, minimal autoloader will not blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. a future Composer implementation. It is easier to start without it, and then add it if we find that we need it. Doing the reverse could prove more difficult, so this path was deemed safer as a first step.
Benefits
The result of that PR is a cleaner and faster codebase. But this change is not only beneficial to Core developers, it will also benefit the ecosystem as a whole:
Reduce friction for plugin developers: Right now, plugin developers usually need to check if a class exists, if it doesn’t then look up its location in Core files, include the file etc. Then and only then can they safely use what WP has to offer. Adding an autoloader makes things easier and removes a friction point for plugin developers who will now be able to directly use a WP class.
Improved performance: – no matter how small the improvement is, it can make a big difference for hosts and larger sites.
This is the first step towards modernizing the WP codebase. Though in itself it may appear like a marginal (but still very worthy) performance improvement, it opens the door to more improvements in the future of WordPress without any backwards-compatibility concerns.
A word about overriding Core classes
One concern has already been raised, and I want to immediately tackle it: adding an autoloader for WordPress Core classes would mean that it will be possible to override these classes by loading another file early enough. We should not base code decisions in Core on how developers might misuse it… There are always ways that someone can mess up WordPress by doing the wrong thing. Being able to override Core classes can be seen both a pro and a con, depending on our point of view – but should not be a deciding factor.
It can benefit hosts who need to override things because of idiosyncracies in their hosting environment.
It can benefit site-builders who don’t know any better and are currently “hacking” Core files, making it impossible to later apply security updates. As WP purists, we know not to ever do that, but we can’t assume that everyone else is as mindful as we are.
It is a shift in the way we think about WP classes, and change is not easy. Autoloading classes is a battle-tested and established good practice in all modern applications.
When adding a new class file to WP-Core, we’ll need to update the classMap accordingly. This is not a big issue however, since we won’t have to include the files we add – just add them to the class-map.
Adding a PHP autoloader to WordPress is a relatively trivial change as the PR demonstrates. It comes with nice benefits and modernizes the way we handle class loading. Because it also represents a fundamental change in the way we include files and classes in the future, your feedback would be greatly appreciated.
Note: This post was updated to correct the format used in one example and remove references to the wapuu w.org username (not officially associated with the project). A note was also added under a list saved as a synced pattern to indicate the contents of the list may change over time. 2/2/2024 – @desrosj
In January 2022, a proposal was published on this blog to implement a new process within any GitHubGitHubGitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ repository under the WordPress organization to ensure anyone and everyone contributing to the project receives due thanks in the form of “props.” The post is still almost entirely accurate and it’s recommended you read that in full. Here are some highlights.
One of the greatest things about open sourceOpen SourceOpen Source denotes software for which the original source code is made freely available and may be redistributed and modified. Open Source **must be** delivered via a licensing model, see GPL. is that contributions come in many shapes and sizes. Anyone can contribute regardless of skill set, experience, time zone, or background. There are countless ways for someone to get involved with open source projects.
WordPress is no different. Contributors submitting code modifications are only a small subset of the larger community. Recognizing all types of contributions is essential to establishing a healthy contributor base, and the responsibility falls on the project’s maintainers. Contributors who feel recognized and valued are more likely to continue contributing.
There is an established and documented policy on the TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress./SVNSVNSubversion, the popular version control system (VCS) by the Apache project, used by WordPress to manage changes to its codebase. side of the project to ensure that everyone contributing to a changeset receives credit (or “props”). This method has been in place for over 12 years, making generating the list of props for each release scriptable and straightforward. The process is unique to the project but frequently receives positive feedback from others in open source.
Since being merged into WordPress CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. in version 5.0, there has yet to be an equivalent process for the contributions on GitHub. The process is manual, does not account for non-code contributions, and often results in contributors not receiving credit for their work.
The post documents the state of props practices and related processes in detail for both Trac/SVN and GitHub. No major changes have been made to these practices since the publish date of that post.
After taking into account all of the feedback received from that proposal, a new policy is now in place for maintainers.
New requirement for GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ GitHub merge commit messages
Starting today, it is required that GitHub merge commit messages for Gutenberg include credits for all contributors following the same guidance as Core SVN commits:
Props should be given to all those who contributed to the final commit, whether through patches, refreshed patches, code suggested otherwise, design, writing, user testing, or other significant investments of time and effort.
In Core SVN, this is done as Props x, y, z. In GitHub, this will be done using Co-authored-by trailers. To avoid having personal emails in the commit log of the project (or having to know which personal email someone has associated with their GitHub account at a given time), a contributor’s GitHub and WordPress.orgWordPress.orgThe community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/ usernames should be used in the following format:
This practice defines a consistent expected pattern that can be reliably parsed by a script to collect contributions for a repository from a GitGitGit is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. Git is easy to learn and has a tiny footprint with lightning fast performance. Most modern plugin and theme development is being done with this version control system. https://git-scm.com/. log in the same fashion as the Core SVN repository.
In order to make this new practice easier for committers and maintainers, a new tool has been merged into the code bases.
Introducing Props Bot
Props Bot is a new GitHub Action that will compile a list of contributors for a given pull request. The bot will leave a comment with a list of contributors formatted for use in both Trac SVN and GitHub.
The comment will be continuously updated as new activity occurs. Additionally, the bot can be manually run by adding the props-bot label to the pull request.
Types of activity included:
Anyone who publishes commits to the PR’s branchbranchA directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch"..
Anyone who left a review or responded to a review on the PR.
Anyone who commented on the PR.
Anyone who created an issue that is attached to the PR.
Anyone who commented on issues attached to the PR.
As of [57517] in wordpress-develop, and 91450bd in WordPress/gutenberg, Props Bot is now available. 🎉
An example comment by Props Bot on a pull request.
The bot relies on an active connection between a WordPress.org and GitHub account. For a step-by-step guide on connecting these accounts, please check out the new page in the Core Handbook.
The bot can be used in any GitHub repository, not just ones under the WordPress organization. However, it’s required for the Gutenberg repository, and official WordPress repositories are strongly encouraged to use it since it will allow the project to appropriately credit contributors in WordPress releases more easily.
What doesn’t Props Bot do?
While the basics of collecting contributors is handled by Props Bot, there are still some things not yet handled by Props Bot:
Manually include someone who has not directly interacted with the PR or linked issues.
Contributors who only interact on Trac tickets relevant to the PR need to be manually included.
Only the first 100 comments are currently checked (see props-bot-action 41).
The easiest way to confirm your accounts are connected is by viewing your w.org profile.
There is one additional step that all contributors should take, even if you have previously connected your accounts.
An added benefit of this new practice is that all props given using this new format will be shown on your GitHub profile’s activity graph. However, this depends on your w.org Git email being added as an alias to your GitHub account (example: desrosj@git.wordpress.org). This can be done by visiting the Settings > Emails page on GitHub.
Note: You’ll see an orange “unverified” notice next to your @git.wordpress.org email after adding it as an alias in GitHub. In the future, email forwarding may be configured to allow these emails to be verified. See this Making Systems request for more information.
How are unlinked contributors handled?
When unlinked contributors are detected, Props Bot will pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” them in the comment, requesting they establish a connection and link to the handbook page.
Any unlinked contributors are noted in the message provided by Props Bot as a way to associate the person’s contributions with their w.org account should they connect their accounts after the PR is merged. This should be included in the merge commit message.
Contributors without a connected w.org account can not be credited in the w.org Credits APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. and will not have their contributions show up on their GitHub profile.
As a Core CommittercommitterA developer with commit access. WordPress has five lead developers and four permanent core developers with commit access. Additionally, the project usually has a few guest or component committers - a developer receiving commit access, generally for a single release cycle (sometimes renewed) and/or for a specific component. or repository maintainer, what do I need to do?
The list of Co-authored-by trailers must be preceded by a blank line.
Co-authored-by trailers should be the last thing in a commit message.
The unlinked contributors must come before the Co-authored-by trailers.
Unlinked contributors should be entered in one line preceded by Unlinked contributors:, each one separated by a comma and a space (, ), and a period after the last one. Example: Unlinked contributors: nacin, matt.
Usernames must not start with an @ (at) sign.
When manually adding someone, please only use their GitHub and WordPress.org usernames in the following format: Co-authored-by: githubusername <dotorgusername@git.wordpress.org>.
The only accounts that are allowed to be noted with a non-w.org email are bot accounts (dependabot or github-actions). It’s important to leave these bots as listed by the GitHub generated Co-authored-by trailer so future contributors know which bots were involved in the changes.
If there are contributors already noted with Co-authored-by in the suggested commit message, verify they are also included in the list provided by Props Bot before removing. These will be in GitHub format and should be converted to the above w.org format. Deleting the GitHub formatted ones will ensure an accurate contributor count for each commit, but it’s not required. Non w.org emails will be ignored by the props parsing scripts.
If a contributor’s w.org username is unknown, add their GitHub username to the “Unlinked contributors” list.
If there are Signed-off-by trailers in the suggested commit message, leave them in place above Co-authored-by trailers. These serve a different purpose and are ignored in the context of collecting props.
Note: The above list is a synced pattern. As it’s improved over time, the changes will be reflected in this post. The above list may be different than what was originally published.
If you don’t see a Props Bot comment on your PR, you may need to pull in the latest changed in trunk.
The action does not currently support using the @v1 notation in the value of uses for a step. For now, using trunk is recommended to help test Props Bot.
The Action has no tests. Contributions are more than welcome!
Because this practice was not in place during the 6.5 release cycle, the previously documented process will be used one more time. The timing of this change is such that the work for 6.6 in the Gutenberg release is about to begin, giving us an entire release cycle using this process and allowing the 6.6 release to switch to automating props collection from the Gutenberg repository.
Summary
While these changes do not solve contribution tracking for every team, every workflow, and every tool that’s to make WordPress, this new practice, combined with the Props Bot action, will bring a consistent standard and level of attribution that can be parsed more easily across more areas of the project.
This is version 1 of this change. All feedback and testing is welcome. There will likely be some refinements required after wider testing!
A WordPress release is a sum of all the contributions made during each release cycle, and use of this Props Bot will help us more accurately thank every contributor. ❤️
Props for Props Bot Contributions
A post about props would not be complete without some props! Big props go out to @dharm1025 for helping to get the initial code converted from a generic JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/. file to a GitHub Action. Thank you to @jeffpaul and @jorbin for working closely to refine the action, create the new handbook pages, modify existing ones as needed, and test the bot. And thanks to @dd32 for creating the underlying w.org API endpoint to return w.org profiles for GitHub usernames making this possible.
“What’s new in GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/…” posts (labeled with the #gutenberg-new tag) are posted following every Gutenberg release on a biweekly basis, showcasing new features included in each release. As a reminder, here’s an overview of different ways to keep up with Gutenberg and the Site Editor project (formerly called Full Site Editing).
This release, which includes 264 pull requests (that’s a lot of work!), can be labeled mainly as a ‘code quality’ one, as it includes two important refactors in both Fonts and Interactivity APIs.
It also includes some improvements in the new “Data Views” experiment, blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience.hooksHooksIn WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same. improvements, and finally, a feature that all developers have been waiting for: the ability to extend allowed blocks within a parent block.
New Block JSONJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. allowed Blocks
Until now, there has been no way to filterFilterFilters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. the allowed blocks in an inner block area. This means that developers could not specify which blocks could be inside a parent block without editing the parent block’s edit file. Imagine you’ve just created an amazing icon block to include in the navigation block; now, you can whitelist it using a filter.
Several smaller edit actions are available in the post editor but not the site editor. The misalignment means users sometimes need to hop between editors, which can be frustrating. This Gutenberg version includes all page edit features in both editors.
Also, the Interactivity APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. and the Fonts Library API have received a big refactor. These APIs are getting close to the 6.5 release, so it’s a great time to test them.
Other Notable Highlights
New Interactivity API directives
The Interactivity API now includes several new directives that will be incredibly helpful when creating interactive blocks.
data-wp-on-window and data-wp-on-document to handle global events like scroll, keypress, load, ready, etc.
data-wp-each to render lists.
data-wp-run to execute custom logic while rendering an element with directives.
Footnotes available for custom post types
Footnotes are available for all post types that
Are public and appear in the REST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/..
Supports all of the following: editor, custom fields, and revisionsRevisionsThe WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision..
Changelog
Features
Interactivity API
Add wp-data-on-window and wp-data-on-document directives. (57931)
Keep Link UI open upon initial link creation when used in RichText. (57726)
List View: Displace list view items when dragging (a bit more WYSIWYGWhat You See Is What You GetWhat You See Is What You Get. Most commonly used in relation to editors, where changes made in edit mode reflect exactly as they will translate to the published page.). (56625)
Show initial suggestions in rich text Link UI. (57743)
Disable lock button if user cannot control lock state. (57274)
Use ClipboardJS latest version and clean up focus loss workaround. (57156)
Dimensions: Add Aspect Ratio block support. (56897)
Block Library
Add more taxonomyTaxonomyA 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. options to the post navigation link. (48912)
Better navigation link variations for post types / taxonomies. (56100)
Remove “blocks” from copy and delete labels. (57769)
Pullquote Block: Add padding and margin support. (45731)
Video Block: Add raw transformation from videohtmlHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers.. (47159)
Aspect ratio: Remove support on the Group block for now. (58414)
Image block: Move UI for lightbox from sidebarSidebarA sidebar in WordPress is referred to a widget-ready area used by WordPress themes to display information that is not a part of the main content. It is not always a vertical column on the side. It can be a horizontal rectangle below or above the content area, footer, header, or any where in the theme. to the content toolbar alongside link settings. (57608)
Data Views
DataViews: Enable grid layout for templates & parts by default. (58137)
DataViews: Make dataviews powered page patterns stable. (58139)
DataViews: Make the “Manage Pages” stable. (58166)
Use a patchpatchA special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. format and support linkTarget of core/button for Pattern Overrides. (58165)
Patterns
Add image block support for pattern overrides. (57909)
Outline editable blocks that are within a content-locked container. (57901)
Add description to the save panel headerHeaderThe header of your site is typically the first thing people will experience. The masthead or header art located across the top of your page is part of the look and feel of your website. It can influence a visitor’s opinion about your content and you/ your organization’s brand. It may also look different on different screen sizes. when nothing is checked. (57716)
Font Library
Update the default collection data URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org to the wordpress.orgWordPress.orgThe community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/ cdn. (58186)
Font Library: Refactor stylesheet using CSSCSSCascading Style Sheets. variables (58237)
Font Library Modal: Reset the selected font when installing a new font. (57817)
Font Library: Disable font library UI using a PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher filter. (57818)
Font Library: Filter fonts upload directory. (57697)
Font Library: Use data or src file to define font collection data. (57734)
Update Navigation block to render hooked inner blocks. (57754)
Add gettext content when translating ‘Header’. (51066)
Template Editor
Remove template-only mode from editor and edit-post packages. (57700)
New APIs
Block API
Block Bindings API: Add block bindings PHP registration mechanisms and “Post metaMetaMeta is a term that refers to the inside workings of a group. For us, this is the team that works on internal WordPress sites like WordCamp Central and Make WordPress.” source under the experimental flag. (57249)
Block Bindings API: Refactor logic into Block Bindings class and singleton pattern. (57742)
Bug Fixes
Block Library
AvatarAvatarAn avatar is an image or illustration that specifically refers to a character that represents an online user. It’s usually a square box that appears next to the user’s name. block: Fix broken aligments in the editor. (58114)
Embed Block: Fix retry processing when embedding with trailing slash fails. (58007)
Lightbox: Fix “Expand on click” control being disabled unintentionally. (56053)
Modified Date Block: Don’t render change date tool. (57914)
Only prioritise Quote transform where relevant. (57749)
Query LoopLoopThe Loop is PHP code used by WordPress to display posts. Using The Loop, WordPress processes each post to be displayed on the current page, and formats it according to how it matches specified criteria within The Loop tags. Any HTML or PHP code in the Loop will be processed on each post. https://codex.wordpress.org/The_Loop.: Fix posts list variation detection. (58194)
#56734 When there is no font, the border should not appear. Display further guidance text. (56825)
Fluid typography: Do not calculate fluid font size when min and max viewport widths are equal. (57866)
Block Editor
Fix regressionregressionA software bug that breaks or degrades something that previously worked. Regressions are often treated as critical bugs or blockers. Recent regressions may be given higher priorities. A "3.6 regression" would be a bug in 3.6 that worked as intended in 3.5.: Content locking does not stops when an outside block is selected. (57737)
LinkControl: Remove unnecessary right padding of input fields. (57784)
Custom Fields
Block Bindings: Fix button popover not showing in patterns. (58219)
Interactivity API: Fix flaky test on-window. (58134)
Fix flaky test on-window, remove duplicate expect on-document. (58181)
Interactivity: Fix broken reactReactReact is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org/. usage in published package. (58258)
Fix visual indication of switch to default template in the post editor. (57718)
Site Editor
(editor)(fix) Append the edit-post-header-toolbar class in NavigableToolbar for backward compatibility with pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party GUI injections. (58154)
AccessibilityAccessibilityAccessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility)
Site Editor
Fix font variants count color contrast ratio and l10nL10nLocalization, or the act of translating code into one's own language. Also see internationalization. Often written with an uppercase L so it is not confused with the capital letter i or the numeral 1. WordPress has a capable and dynamic group of polyglots who take WordPress to more than 70 different locales.. (58117)
Make the site hub View Site link always visible. (57423)
Block Editor
Fix parent selector button focus style and metrics. (57728)
Restore visual separator between mover buttons when show button label is on. (57640)
Widgets Editor
Fix Widgets page Undo and Redo accessibility and keyboard interaction. (57677)
Block editor: Avoid list re-rendering on select. (57188)
Block editor: Don’t register shortcuts for preview editors. (57984)
Block editor: Fix performance regression after #57950. (57971)
Block editor: Use context for useBlockEditingMode. (57950)
BlockSwitcher: Defer transform calculations until the Dropdown is open. (57892)
Call variation through callback so it’s only loaded when needed – in support of tracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. 59969. (56952)
Footnotes: Combine format store subscription. (58129)
IframeiframeiFrame is an acronym for an inline frame. An iFrame is used inside a webpage to load another HTML document and render it. This HTML document may also contain JavaScript and/or CSS which is loaded at the time when iframe tag is parsed by the user’s browser.: Calc compat styles once per page load. (57798)
Measure typing with the top toolbar enabled. (57709)
Meta boxes: Don’t initialise if there are none. (57182)
Components: Move CHANGELOG entries under the correct release. (57885)
Docs: Fix typo in “The block wrapper” document. (58106)
Docs: Use ‘key’ in ‘editor.BlockEdit’ filter code examples. (58119)
Document files/directories requiring backmerging to WP CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. for major releasemajor releaseA release, identified by the first two numbers (3.6), which is the focus of a full release cycle and feature development. WordPress uses decimaling count for major release versions, so 2.8, 2.9, 3.0, and 3.1 are sequential and comparable in scope.. (58064)
Fix the iframe markup of the embed video in the Quick Start Guide. (57857)
Remove unused state and rename props to attributes in getElement(). (57974)
HTML API
BackportbackportA port is when code from one branch (or trunk) is merged into another branch or trunk. Some changes in WordPress point releases are the result of backporting code from trunk to the release branch. updates from Core. (57022)
Update the cherry pick script to work with the new version of gh. (57917)
Scripts: Remove unused variable in bin/list-experimental-api-matches.sh. (57771)
(chore) Revert bump to the v17.5.1 (draft) due to bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. in the release found by manual testing. (58027)
December 14, 2023: extended the deadline to January 12, 2024.
January 16, 2024: extended the deadline to January 31, 2024.
Nominations are now closed.
This post kicks off the formal election process with a call for nominations for the 2024 CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. Team Reps. For 2023, Tonya Mork (@hellofromtonya) and Abha Thakor (@webcommsat) have served as the elected Core Team Reps.
The Roles
In the WordPress open sourceOpen SourceOpen Source denotes software for which the original source code is made freely available and may be redistributed and modified. Open Source **must be** delivered via a licensing model, see GPL. project, each team has on average one or two representatives, abbreviated as reps. For the historians out there, the roles goes way back to 2012.
Historically with the Core team, the team repTeam RepA Team Rep is a person who represents the Make WordPress team to the rest of the project, make sure issues are raised and addressed as needed, and coordinates cross-team efforts. duration was around a year, though some reps stuck around longer if there was a particularly good fit.
It is not called “team lead” for a reason. It’s an administrative role. While people elected as team reps will generally come from the pool of folks that people think of as experienced leaders, the team rep role is designed to change hands regularly.
This role has a time commitment attached to it of at least a one or two hours a week.
writing regular Core team recaps and posting it in the Updatesblogblog(versus network, site).
writing the Week in Core post. In 2023, this has been kindly continued to be done with thanks to previous team rep @audrasjb.
keeping a watch on the moving parts of the team to report for quarterly updates (example).
How the election works
Please nominate people in the comments of this post. Self-nominations are welcome. The deadline is January 31, 2024 at 23:59 UTC. If there are less than 2 nominees who accepted their nominations, the deadline will again be extended.
Once nominations period expires, then a poll will be opened for voting. It will stay open for two weeks. The new reps will start their role in February 2024.
Disclaimer: if you are nominated, please don’t feel like you have to agree to say yes. The election poll will only include the names of the people who have agreed to be nominated. So feel free to reply with a “Thank you, but no thank you”.
If you have any questions, please feel free to ask in the comments or speak to the current team reps. Finally for reference, these are the 2020, 2021 and 2022 nomination posts.
In this dev notedev noteEach important change in WordPress Core is documented in a developers note, (usually called dev note). Good dev notes generally include a description of the change, the decision that led to this change, and a description of how developers are supposed to work with that change. Dev notes are published on Make/Core blog during the beta phase of WordPress release cycle. Publishing dev notes is particularly important when plugin/theme authors and WordPress developers need to be aware of those changes.In general, all dev notes are compiled into a Field Guide at the beginning of the release candidate phase., you will find a collection of smaller changes to existing features and APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. updates. For component updates, please see also Updates to user-interface components in WordPress 6.4.
Background image blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. support
In WordPress 6.4, a new background image block support has been added, with the Group block opted-in by default. For themes using the appearanceTools feature in theme.json, the control will be available in the inspector controls, under Background.
The feature allows users to set a background image for a Group block. The selected image will be output at render-time for the block via an inline style applied to the block’s wrapper. When a background image is set, the rule background-size: cover is output along with the background-image property. This ensures that any background images adequately cover the block. Ideas for enhancements in future releases are being tracked in this GitHubGitHubGitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ issue: #54336
How to add backgroundImage support to a theme
There are two ways to add support for backgroundImage to a block theme. The simplest is to opt in to the appearanceTools setting, which automatically enables a number of design tools (read more in the developer handbook).
For themes that wish to have more granular control over which UIUIUser interface tools are enabled, the backgroundImage support can be opted into by setting settings.background.backgroundImage to true in theme.json. For example:
FilterFilterFilters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. behavior when using new Expand on Click in Image block
If your image block with `Expand on Click` enabled has Lightbox markup that you can’t seem to access from inside your filter function, below is some extra information you might need.
As of WordPress 6.4, please be aware that a built-in filter for the image block has been applied with priority 15 for images with `Expand on Click`. This means that if your filter has a priority of 15 or lower (the default is 10), then the markup used to create the Lightbox behavior will not be available to your function for processing by default.
Please make sure to use priority of at least 16 when adding filters to process the image block if you need to access the Lightbox markup.
Fluid typography: configurable minimum and maximum viewport values
WordPress 6.4 introduces configurable minimum and maximum viewport width values to fluid typography settings in theme.json.Theme developers can now define their own default viewport “boundaries” for calculating fluid font sizes. These boundaries determine the browser viewport widths at which any font size clamp values will stop being “fluid”.
For example, given the following theme.jsonJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. settings:
Between the browser widths of 600px and 800px, a font size will be fluid, and therefore scale up or down according to the current viewport size. If the browser width is narrower than 600px or wider than 800px, the font size will no longer shrink or grow.
Due to the way the Block Editor calculates fluid font size values, maxViewportWidth and minViewportWidth only accept px, rem and em units.
In the case of unsupported values, including CSSCSSCascading Style Sheets. variables, fallback maxViewportWidth and minViewportWidth are used –1600px and '320px' respectively.
With WordPress 6.4, it is now possible to disable layout controls globally for all blocks or on a per-block level from theme.json. This ensures that affected blocks still output their default layout styles, but the controls to edit them won’t be available in the block sidebarSidebarA sidebar in WordPress is referred to a widget-ready area used by WordPress themes to display information that is not a part of the main content. It is not always a vertical column on the side. It can be a horizontal rectangle below or above the content area, footer, header, or any where in the theme..
To disable the controls for all blocks, "allowEditing": false should be added to settings.layout, like so:
RichText’s multiline prop replaces with simple multiple instances
RichText‘s multiline prop has been deprecated since 6.1 and was scheduled for removal in 6.3. We’re leaving the deprecated prop in place, but its functionality has been simplified internally, so you may experience changes.
Instead of one large rich text field, each line is now its own rich text field. Contributors added a splitting and merging functionality, so the fallback is gracious, but some things like paste may work differently. It’s worth noting that this prop remains deprecated and all block authors are encouraged to use InnerBlocks instead.
New public hook in the Block Editor API: useBlockEditingMode()
Blocks can set an editing “mode” using the useBlockEditingMode hook. useBlockEditingMode() allows a block to restrict the user interface that is displayed for editing that block and its inner blocks.
The block editing mode can be one of three options:
'disabled': Prevents editing the block entirely, that is, it cannot be selected.
'contentOnly': Hides all non-content UI, for example, auxiliary controls in the toolbar, the block movers, block settings.
'default': Allows editing the block as normal.
The block editing mode is inherited by all the block’s inner blocks, unless inner blocks have their own modes set.
Usage:
function MyBlock( { attributes, setAttributes } ) {
useBlockEditingMode( 'disabled' );
// MyBlock will be marked as 'disabled' editing mode.
return ;
}
useBlockEditingMode() also returns a block’s current editing mode, which can be utilized to further configure block properties. For example, a component inheriting its parent’s block editing mode:
function ChildComponent( props ) {
const blockEditingMode = useBlockEditingMode();
let text = 'Child component';
if ( blockEditingMode === 'disabled' ) {
// Block is disabled, add custom block properties to indicate disabled mode.
text+= ' is disabled!';
}
if ( blockEditingMode === 'default' ) {
// Block can be edited, show controls or other editing-related settings. \
}
return
Three experimental APIs were stabilized in WordPress 6.4. That means they should be safe from backward-compatibility issues when you use them in production:
Introduce SCRIPT_DEBUG to make package compatibile with Webpack 5
This change in WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. is mostly an internal optimization to send less code to the browser. It could be useful for developers using @wordpress/scripts that it is possible to hide code behind this debug flag.
if ( typeof SCRIPT_DEBUG !== 'undefined' && SCRIPT_DEBUG === true ) {
// This code runs only in the development mode and gets completely removed from the production build.
}
Following the post Evolving the FSE Outreach Program, there was a transition period of six months after the 6.4 release and the end of Phase 2. Now let’s discuss what could happen after this period.
This post recommends the next steps. Before that, some clarification of terms might be in order:
Site builder = No code/low code user who builds sites for others
Extender: Developers/designers who build plugins and themes or work for agencies or as freelance developers/designers.
Because site builders and Extenders regularly intersect, the channel’s content and discussions will be relevant to both groups of users.
A good first step could be to rename the channel from #fse-outreach-experiment to #outreach, as it will be about more than FSE, and no longer an experiment.
Several projects could use SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/. support in the WordPress space for discussion, clarification, and overall ruminating on future features coming to WordPress. A list of discussions, sharing, and information that could be shared in the channel follows. None of them are exclusive, but they made the list because they don’t necessarily fit other channels.
The ideas also don’t warrant a separate channel, but all ideas come from knowing that non-contributors need to connect with contributors. As noted in comments on the previous post, a clear outcome of the FSE Outreach program was that connecting in this channel facilitated participants’ first contributions and lowered the barrier to connecting with the open-source project.
The channel is a place for attendees and viewers of regular Developer Hours to connect with presenters. The discussion could cover the event’s topic beyond the live event. The same is true for the Hallway Hangouts. Resources for both events will be shared in the channel.
Once the Test team, or any other team, issues a new call for testing, the feedback would be surfaced here in a conversation about challenges and to help answer questions.
There might be a breaking change in an upcoming release that needs attention from extenders.The channel can provide space for additional discussion on workarounds, etc.
Excerpts from the Dev Chat agenda/summary of the user-facing updates from contributors can be shared, if they are relevant for site builders and extenders.
In collaboration with design and engineering teams, discussion from GitHubGitHubGitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ and TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. can be raised in the channel to solicit input from those interested in the topics.
The outreach channel is also the place to point people to from other networks (X, Mastodon, or Facebook) when there is a need to discuss issues/topics that are outside the scope of the Support team and require a WordPress space to get a few people in from other teams involved.
The channel could also be a resource for MeetupMeetupAll local/regional gatherings that are officially a part of the WordPress world but are not WordCamps are organized through https://www.meetup.com/. A meetup is typically a chance for local WordPress users to get together and share new ideas and seek help from one another. Searching for ‘WordPress’ on meetup.com will help you find options in your area. Organizers who have questions or need advice on facilitating local discussions about upcoming features.
Independent of the list of activities, the #outreach (working title) Slack channel will continue as a central point of contact with the community.
This can only be a group endeavor if we want to broaden the reach and be a welcoming place for people interested in particular focuses of the software. Quite a few people raised their hands to be part of a continuation of the outreach program, be it to participate in discussions or to follow future calls for testing. If you are interested, please let us know in the comments!
All feedback on this proposal is welcome. Here is a set of questions that could get you started:
Naming things is hard, so what do you think about the future name “outreach”? Any other ideas for a name?
What do you think about the eight ideas shared about what a conversation might look like in the channel?
Do you have any other ideas for community outreach that could have a place here?
Feedback by February 12th would be appreciated.
Nick Diego, Justin Tadlock, and I would like to invite contributors to a Hallway Hangout on February 20th, 2024, at 15:00 UTC to discuss this proposal, the comments, and the next steps.
WordPress 6.5 is set to be released on March 26th, 2024. This release brings greater design control and optionality, more robust blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. capabilities with new APIs, access to current block theme functionality for classic themes, and the start of the new adminadmin(and super admin) redesign. More specifically, these significant features include the Font Library for easy global font management, support for Appearance Tools in Classic Themes for more expansive design options, and more robust revisionsRevisionsThe WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision. across the editing experience (including revisions for template parts and templates). New APIs like Interactivity, Custom Fields, and Block Binding expand block capabilities and underpin features like partial sync patterns, and PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher compatibility work ensures alignment with PHP versions. Rollback for pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party and theme updates enhances safety, and bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. fixes address various components for an improved user experience. The first taste of the admin redesign as part of phase 3 efforts are planned for this release in an iterative and contained way by bringing a new experience to the template, template part, and pattern lists within the Site Editor.
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.5.
For a more detailed look at the work related to the block editor, please refer to the 6.5 board.
Design tools
Font Library
The Font Library makes it easy for anyone to install, remove, and activate fonts across your site. It’s available globally, independent of the theme activated, similar to the Media Library. Any installed font, whether installed by a user or a theme, can then be selected across the editing experience.
Syncing specific blocks and attributes of patterns
Building upon synced patterns, pattern overrides (previously called partial sync patterns) would allow users to ensure a synced layout and style across patterns while allowing each instance of the pattern to have customized content. This allows for consistency in design across different pieces of content. For instance, consider a testimonial pattern in a grid. With the enhanced feature, someone can insert this testimonial pattern into multiple posts, ensuring that the layout and styling components, such as the overall design of the recipe card, remain consistent across instances. Meanwhile, the content, such as Name, Image, and Role, would be local to each instance allowing for individual customization. Additionally, folks would then be able to revisit and modify the design of the overall testimonial pattern without affecting the content in existing instances. Of note, this work will need to align with the following Custom Fields API and Block Binding API.
Section Specific Theme.jsonJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. and Colorways
Taking the high level styling system with features like style variations, section specific theme.json offers more granular control for defined parts of your site using that same underlying system. This is a broad set of work and, for 6.5, the aim is to bring color variations to group blocks via the idea of Colorways. Colorways is a subset of section-specific theme.json, with styling elements only. This option would only be available for Group blocks for 6.5 in a code only way except for a minor UIUIUser interface to select. These styles would apply curated color, typography, border styles etc along with styles for elements (links, buttons etc). For now, the most common use case is a theme author creating them for a theme to provide a predefined set of colors that have been preselected based on appropriate contrast, aesthetics, and more. In the future, work is being explored to allow users to create them in the Styles interface.
Adding support for Appearance Tools opens a world of design options that, up until this point, have been only available with Block Themes, or themes using theme.json. For example, adding a simple border to a Group block requires support for Appearance Tools. Work is underway to allow Classic Themes to add support for most of these tools safely, without breakage, unlocking more design options for more sites in a big way.
Paving the way for improved Pattern management in Classic Themes
Thanks to some internal code changes, the path is being set for a future release to enable Classic Themes access to the new Patterns experience that the Site Editor provides. Separately, a link for Appearance > Patterns is going to be added for Classic Themes to make Patterns more readily accessible and visible as a feature. This will link to the current patterns experience already in Classic Themes.
New data views for templates, template parts, and patterns in the Site Editor
This work kicks off aspects of the Admin Redesign effort in an iterative and contained way by bringing a new experience to the template, template part, and pattern lists within the Site Editor. The following features are planned:
Ability to display a table with specific fields, pagination and quick actions.
Toggling fields and sorting and filtering data by field.
UI for selecting entries and performing bulk actions.
Support for different layouts, like classic table, grid view (including gallery), with the option to display a side-by-side preview.
Support for saving and toggling between “views”, which are specific configurations of layouts, field visibility, etc.
This feature-rich experience provides immediate value both to the Site Editor and begins to lay the groundwork for future work related to Phase 3, including efforts around Workflows and Media Library.
Revisions help create confidence when writing and creating, knowing your changes are always safely stored. For WordPress 6.5, templates and template parts will now display revisions, alongside broader upgrades to style revisions with plans for side by side comparisons, pagination, more detailed descriptions, and more.
6.5 seeks to move the needle with responsive controls by adding the ability to fully customize what your overlay menu will look like. The navigation overlay is the name for the menu that’s shown when you set and open a mobile menu. Having full control over this mobile menu would allow you to customize the colors, spacing, and blocks offering the option for a distinct menu experience across devices.
Interactivity APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways.
The Interactivity API aims to be a standard way to allow developers to add interactivity to the frontend of their blocks, like hearting a post or adding to cart without page loads. A standard makes it easier for developers to create rich, interactive user experiences, from simple cases like counters or popups to more complex features like instant page navigation, instant search, or carts and checkouts. After testing the API on specific coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. provided blocks for months in the GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ plugin and, more recently, in core with WordPress 6.4, there are a few remaining tasks to expose the API for extenders: “store refactoring” based on feedback from early adopters, server-side directive processing that covers SEO requirements and optimizes initial renders, and adding support for ES Modules and import maps. Each of these are projects in their own right and will need to be evaluated for the release.
This feature aims to create a simple way of connecting block attributes and Custom fields/metadata. Because this is such a broad undertaking, a scaled back version is planned for 6.5 that would accomplish the following:
Connect block attributes and custom fields without a UI.
Include a basic UI to create these bindings where the API can read the metadata value
Add the possibility to edit the value of the metaMetaMeta is a term that refers to the inside workings of a group. For us, this is the team that works on internal WordPress sites like WordCamp Central and Make WordPress. field directly through the editing experience.
Add support for more core blocks based on importance and relevancy.
This API aims to connect block attributes to values, obtained from different sources, that might vary depending on the context. For example, a value like post_author that changes depending on the current post. This will expand the capabilities of existing blocks without the need to create new ones, which will empower theme developers and site owners. For example, having a heading block with the content of the Post Author without needing a new Post Author block. For 6.5, the work for this API will mainly be focused on serving other pieces of the roadmap, namely Custom Fields and Partial Sync Patterns.
Several compatibility fixes are scheduled to ship with 6.5, with work underway to improve compatibility with PHP 8.0, 8.1, and 8.2.
Since the adoption of a tiered PHP 8+ compatibility plan, each release brings the opportunity to update official PHP compatibility information for the new, as well as previous, versions of WordPress. Using current data from each PHP 8.x version’s usage metrics and open compatibility issues, exceptions will be cleared or added, and updates applied to the version chart. Significant exceptions might also warrant a dedicated Make/Core post with additional details.
The official release of PHP 8.3 in late November means that site operators and hosting companies will want to know if WordPress 6.5 is compatible with the latest PHP. Technical exceptions called out on the PHP compatibility page do not provide many users a clear answer to this question. Barring any major issues with running 6.5 on PHP 8.3, it may be helpful to publish an official compatibility notice on WordPress/News (see this example clarifying WordPress 6.4 compatibility on PHP 8.1 and 8.2).
Rollback for plugin and theme updates for automatic updates
Building on prior efforts released in WordPress 6.3, rollbacks for automatic updates to plugins is underway. Specifically, this means that checks will be added to ensure that an updated plugin does not cause a PHP fatal error when the plugin is active during an auto-update.. If it does, this error is captured and the previously installed version is restored, along with an email sent to the site admin.
Currently, any plugin that requires another plugin (i.e., a dependency) is on its own to make sure admins install the dependency since the plugin won’t work without it. To ease that process for everyone involved, work has been underway to create a consistent method to handle dependencies and provide a clear pathway for folks to know the relationship and take proper action while installing these kinds of plugins. Namely, the current approach prevents activation of a dependent plugin if its dependences are not installed and activated. If dependences suddenly become unavailable (such as if a dependency’s directory is manually deleted), the dependent plugin is automatically deactivated. To learn more about this effort, please review the Feature Project: Plugin Dependencies post.
While performance is a constant focus and each new feature must be reviewed for performance impact, a few priority projects are on the performance team’s list to address for 6.5:
Raising the minimum version of MySQLMySQLMySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com/.
MySQL 5.0 was initially made generally available in 2005 and reached its end of life (EOL) in January of 2012, making it unsupported and insecure for over 12 years. This is extremely old and this requirement is being raised. In WordPress 6.5, the minimum required version of MySQL will be raised from 5.0 to 5.5.5.
These “CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. Editor Improvement…” posts (labeled with the #core-editor-improvementtagtagA 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.)) are a series dedicated to highlighting various new features, improvements, and more from Core Editor related projects.
RevisionsRevisionsThe WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision. are an integral part of the creation experience, providing a safety net and a way to see where you’ve been to know where to go next. It’s so important that there’s a dedicated area of focus for phase 3 efforts dedicated to the broader area of work! While lots of work lies ahead, WordPress 6.5 is slated to include some impactful changes and new features to current revision functionality in the Site Editor.
If you want to try out what’s shared below for yourself, head over to the post on Early Opportunities to Test WordPress 6.5 where you can quickly spin up your own test site to experience it for yourself and give feedback. Everything shared below is available as of GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ 17.4 and planned for inclusion in WordPress 6.5.
Let’s look at a before and after
To help bring these changes to life, below is a video showcasing what’s written below. The “before” site is using WordPress 6.4.2 and the “after” site is using WordPress 6.4.2 with Gutenberg 17.5.1 installed. These test sites were pulled from Early Opportunities to Test WordPress 6.5 so anyone is welcome to explore:
Read a short summary of styling changes thanks to a new design
Alongside a new design showing more granular information, like a more granular timestamp, a short summary of changes made in each revision is now available. Combined, this greatly simplifies understanding what’s in each revision rather than relying on spotting visual changes.
View all style revisions thanks to pagination
Rather than showing just the last 100 revisions, all revisions are now available thanks to pagination. This both works around a technical limitation of 100 results per REST response and helps make navigating between revisions much easier than scrolling endlessly in the sidebarSidebarA sidebar in WordPress is referred to a widget-ready area used by WordPress themes to display information that is not a part of the main content. It is not always a vertical column on the side. It can be a horizontal rectangle below or above the content area, footer, header, or any where in the theme..
Toggle on the Style Book to get a different angle
In the same way you might be used to using the Style Book when making changes to your site in the Site Editor, you can now do the same when looking at different revisions to see changes that might not otherwise be visible on the current template. Just as when you use the Style Book normally, you can toggle it on and off as you’d like.
Rely on full revisions for everything
While the undo and redo buttons have a role to play, having access to full revision history allows for a much greater understanding of changes, their impact, and actions one can take. While this was mentioned in a previous post, revisions for templates and template parts are finally slated for inclusion in Core for WordPress 6.5. This means out of the box folks can browse changes to templates, template parts, and styles providing a nice safety net.
“What’s new in GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/…” posts (labeled with the #gutenberg-new tag) are posted following every Gutenberg release on a biweekly basis, showcasing new features included in each release. As a reminder, here’s an overview of different ways to keep up with Gutenberg and the Site Editor project (formerly called Full Site Editing).
The editor unification project is working to combine the Post Editor and the Site Editor into one unified editor. This release brings that goal closer by combining many of the preferences for these two editors into one shared preferences panel.
Gallery BlockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience.: Random Order Setting
In #57477 we added a new setting to the Gallery block which allows you to give your gallery images a random order. This feature was available in the gallery shortcodeShortcodeA shortcode is a placeholder used within a WordPress post, page, or widget to insert a form or function generated by a plugin in a specific location on your site., but not in the gallery block, until now!
Other Notable Highlights
Post Featured ImageFeatured imageA featured image is the main image used on your blog archive page and is pulled when the post or page is shared on social media. The image can be used to display in widget areas on your site or in a summary list of posts.: Add a useFirstImageFromPost attribute. (56573)
Update @ariakit/reactReactReact is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org/. to v0.3.12 and @ariakit/test to v0.3.7. (57547)
Font Library
Font Library: Remove “has_font_mime_type” function. (57364)
Font Library: Update font uninstall modal text. (57368)
Font Library: Add progress-bar while uploading font assets. (57463)
Font Library: Singularize install font families endpoint. (57569)
Add Template Modal: Update scroll related layout. (57617)
Components: Replace TabPanel with Tabs in the Font Library Modal. (57181)
Interactivity APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways.
Navigation Block: Use dom.focus for focus control. (57362)
Site Editor
Site editor: Add padding to entity save panel headerHeaderThe header of your site is typically the first thing people will experience. The masthead or header art located across the top of your page is part of the look and feel of your website. It can influence a visitor’s opinion about your content and you/ your organization’s brand. It may also look different on different screen sizes.. (57471)
Site editor: Add margin to entity save panel header via a classname. (57473)
Block Library
Post Featured Image: Add a useFirstImageFromPost attribute. (56573)
Avoid using a memoized selector without dependencies. (57257)
CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. Data: Pass the ‘options’ argument to data action shortcuts. (57383)
Preferences: Update accessibilityAccessibilityAccessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) scope to “core”. (57563)
Block Editor
Fix Link UIUIUser interface displaying out of sync results. (57522)
Give iframeiframeiFrame is an acronym for an inline frame. An iFrame is used inside a webpage to load another HTML document and render it. This HTML document may also contain JavaScript and/or CSS which is loaded at the time when iframe tag is parsed by the user’s browser. fallback background color. (57330)
Rich text: Add HTMLHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. string methods to RichTextData. (57322)
Block Library
Footnotes: Fix wrong link when adding more than 9 footnotes. (57599)
Table: Remove unnecessary margin override in editor styles. (57699)
Template Part block: Fix template part path arg missing from actions. (56790)
Components
DuotonePicker: Fix top margin when no duotone options. (57489)
NavigatorProvider: Exclude size value from contain CSSCSSCascading Style Sheets. rule. (57498)
Edit source pattern in focus mode in post and site editors. (57036)
Site Editor
Make sure comamnd palette toggle does not disappear while being clicked. (57420)
Reinstate iframe CSS for editor canvas container. (57503)
Global Styles
Use is-layout pattern on layout generated classname. (57564)
Global styles revisionsRevisionsThe WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision.: Add individual headings translations, update tests. (57472)
Global style revisions: Move change summary code and tests to block editor package. (57411)
Reduce specificity of block style variation selectors. (57659)
Background image block support: Add tests for size and repeat output. (57474)
Post Editor
Fix Template preview menu item accessibility. (57456)
Fullscreen mode description: Use full text instead of abbreviation. (57518)
NumberControl: Make increment and decrement buttons keyboard accessible. (57402)
Block Tools
Update the position of the patterns tab in the inserter menu. (55688)
Use full text instead of abbreviation for min height setting. (57680)
ResizableEditor: Fix tab order for resize handles. (57475)
Keep Lock button it in the toolbar until unmounted. (57229)
Custom fieldCustom FieldCustom Field, also referred to as post meta, is a feature in WordPress. It allows users to add additional information when writing a post, eg contributors’ names, auth. WordPress stores this information as metadata. Users can display this meta data by using template tags in their WordPress themes. connections: Better description on Experiments page. (57501)
Performance
Block Library
File: Remove ‘block-editor’ store subscription. (57511)
Remove store subscriptions from Audio and Video blocks. (57449)
Site Logo: Remove unnecessary ‘block-editor’ store subscription. (57513)
Send numerical post id when uploading image. (57388)
PostFeaturedImage: Remove unnecessary ‘block-editor’ store subscription. (57554)
Experiments
Data Views
DataViews: Use DropdownMenuRadioItem component when possible. (57505)
Align icon size + placement in Patterns data view. (57548)
DataViews: Add duplicate pattern action in patterns page. (57592)
DataViews: Add footer to Pages sidebarSidebarA sidebar in WordPress is referred to a widget-ready area used by WordPress themes to display information that is not a part of the main content. It is not always a vertical column on the side. It can be a horizontal rectangle below or above the content area, footer, header, or any where in the theme.. (57690)
DataViews: Add sync filterFilterFilters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. in patterns page. (57532)
Add links to additional local dev tools in Block Developement Environment readme. (57682)
Add new section to the Quick Start Guide about wp-env. (57559)
Block JSONJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. schema: Add renaming key to supports definition. (57373)
Break out the Curating the Editor Experience doc into its own How-to Guides section. (57289)
Change the slug for the theme.json doc to avoid conflicts. (57410)
Docs/tutorial: Fix opposite condition for content generation in render.php. (57445)
Docs: Fundamentals of Block Development – Static or Dynamic rendering of a block. (57250)
Docs: Update sample code to fix React warning error on Tutorial page. (57412)
Fix formatting issue due to incorrect link parsing in the Quick Start Guide. (57693)
Fix incorrect heading level in Editor curation documentation. (57409)
Navigation: Refactor mobile overlay breakpoints to JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors.. (57520)
Editor: Use hooksHooksIn WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same. instead of HoCs in ‘PostVisibilityCheck’. (57705)
Quality: Avoid React warning when changing rendering mode. (57413)
Dependency Extraction Webpack PluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party: Use import for module externals. (57577)
DependencyExtractionWebpackPlugin: Add true shorthand for requestToExternalModule. (57593)
DependencyExtractionWebpackPlugin: Use module for wordpress/interactivity. (57602)
Fix webpack not setting environment.module true. (57714)
Modules: Load the import map polyfill when needed. (57256)
Blocks: Add handling for block.json viewModule. (57437)
Testing
Allowed Patterns end-to-end test – move tests that run with a subset of allowed blocks into a group. (57496)
Migrate ‘allowed patterns’ end-to-end tests to Playwright. (57399)
Migrate ‘block editor keyboard shortcuts’ end-to-end tests to Playwright. (57422)
Migrate ‘core settings’ end-to-end tests to Playwright. (57581)
Migrate ‘datepicker’ end-to-end tests to Playwright. (57545)
Migrate ‘dropdown menu’ end-to-end tests to Playwright. (57663)
Migrate ‘editor modes’ end-to-end tests to Playwright. (57574)
Migrate ‘invalidinvalidA 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. blocks’ end-to-end tests to Playwright. (57508)
Migrate ‘nux’ end-to-end tests to Playwright. (57542)
Migrate ‘preferences’ end-to-end tests to Playwright. (57446)
Migrate ‘publishing’ end-to-end tests to Playwright. (57521)
Migrate ‘scheduling’ end-to-end tests to Playwright. (57539)
Migrate ‘sidebar’ end-to-end tests to Playwright. (57448)
Migrate ‘taxonomies’ end-to-end tests to Playwright. (57662)
Migrate remaining ‘publish panel’ end-to-end tests to Playwright. (57432)
Update ‘missing block’ end-to-end tests to use the ‘setContent’ helper. (57509)
Build Tooling
Group GitHubGitHubGitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ Action Dependabot updates. (57591)
You must be logged in to post a comment.