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.
Happy new year, everyone! Here’s some aggregate data for 2023 about WordPress CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. contribution on TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress..
Please note:
These data only include code contributions to WordPress codebase, not contributions on 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/ repositories such as 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/.
The raw data for this post are available on this public spreadsheet. You might find that much easier to read if you have low vision or colorblindness; the graphics below are a snapshot pulled together to include as much information as possible in this blogpost, but they are hard to make accessible to everyone.
All the links for the graphics below open a new tab to display them in full size.
General Trac overview
In 2023, the WordPress Core team shipped 2211 commits (2597 in 2022). 2751 tickets were opened, 2545 tickets were closed, and 365 were reopened.
Also, 1079 people contributed to WordPress source code using Trac (988 in 2022), and 472 people made their very first contribution to WordPress Core ♥️ (398 in 2022).
January
February
March
April
May
June
July
August
September
October
November
December
Total
Commits
148
265
179
84
174
246
209
173
250
288
108
87
2211
Tickets closed
181
297
218
156
179
259
211
277
239
268
148
112
2545
Tickets reopened
25
36
36
19
25
40
42
29
35
40
28
10
365
Tickets created
185
234
208
188
208
255
256
310
250
270
212
175
2751
New contributors
18
91
23
18
25
74
51
31
75
46
12
8
472
Contributors
137
295
155
87
150
279
217
182
295
249
111
93
1079
This chart shows the number of commits per month in 2023, and the number of closed, reopened and created tickets per month. It also shows the number of contributors per month in 2023. It can be scrolled horizontally.
Check out the Trac timeline in the graphs below:
Here’s how many props and new contributors the Core project had per month. The most prolific months were February and September with 295 contributors each, followed by June and October. 42 of the new contributors received their first props on a commit related to the Twenty Twenty-Four theme.
Components activity
How did 2023’s commits break out by Core Component?
The most prolific components were:
Editor with 284 commits (12.8% of all listed commits)
Build/Test Tools with 265 commits (12% of all listed commits)
Docs with 188 commits (8.5% of all listed commits)
Coding Standards with 154 commits (7% of all listed commits)
Bundled Themes with 130 commits (5.9% of all listed commits)
Then came Media, Help/About, Code Modernization (which is not an official component), Themes, Administration, General, HTMLHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers.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., Internationalization, 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/. and Upgrade/Install. The other components each had fewer than 30 commits this year.
Contributors data retrieved from 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/ profiles
The data below comes from matching contributors’ usernames, as mentioned in Trac props, with their profiles on WordPress.org.
One caveat: this ignores usernames that did not match a profile on dotorg, plus any that had blank or unusable country/company information (“The Universe” or “Unicorn land” are not known countries 🙂).
Contributions by country
The next graph shows the number of props received by country. The top eight countries, based on the number of props received, are these:
United States with 2062 contributions (1255 in 2022)
Russiawith 795 contributions (1152 in 2022)
India with 683 contributions (317 in 2022)
France with 680 contributions (739 in 2022)
Australia with 611 contributions (386 in 2022)
United Kingdom with 471 contributions (216 in 2022)
Ireland with 403 contributions
Bangladesh with 340 contributions (145 in 2022)
Contributors (people) by country
In 2023, people from at least 62 countries contributed to WordPress Core (57 countries in 2022).
Here are the top eight countries by number of contributors:
United States with 164 people (152 in 2022)
Bangladesh with 105 people (only 43 in 2022)
India with 93 people (77 in 2022)
United Kingdom with 31 people (38 in 2022)
France with 30 people (22 in 2022)
Canada with 25 people (17 in 2022)
Germany with 21 people (25 in 2022)
Netherlands with 21 people (23 in 2022)
Spain with 19 people (12 in 2022)
Contributions by company
In 2023, people from at least 286 companies contributed to WP Core.
These companies (well, their employees) each contributed to more than 100 commits:
Automattic with 1770 contributions (866 in 2022)
Yoast with 985 contributions (1452 in 2022)
10up with 904 contributions (501 in 2022)
Whodunit with 561 contributions (676 in 2022)
Google with 404 contributions (130 in 2022)
Bluehost with 238 contributions (226 in 2022)
XWP with 224 contributions (14 in 2022)
Human Made with 177 contributions (126 in 2022)
Advies en zo with 143 contributions (220 in 2022)
Dream Encode with 128 contributions (124 in 2022)
Emilia Capital with 123 contributions
Accessible WD with 120 contributions (53 in 2022)
GoDaddy with 111 contributions (42 in 2022)
Contributors (people) by company
A huge number of companies have only one contributor—or very few contributors. The exceptions are Automattic, with 108 core contributorsCore ContributorsCore 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. on Trac in 2023, WPDeveloper (39 contributors), 10up with 25 contributors, AuthLab (21 contributors), rtCamp (17 contributors), Awsm (12 contributors), Human Made (12 contributors), Multidots (12 contributors), and Yoast (10 contributors). Only these 9 companies had at least 10 people credited on Trac in 2023.
What did 2022 hold for Core Committers?
39 Core Committers committed code to the WordPress SVNSVNSubversion, the popular version control system (VCS) by the Apache project, used by WordPress to manage changes to its codebase. repository this year (32 in 2022):
Of the 2211 commits, 555 (25%) were made by people working at Yoast, 413 (19%) from people working at Whodunit, 399 (18%) from employees of Automattic, followed by Google (151 commits), Bluehost (148 commits) and 10up (123 commits).
Automattic is the only company with more than 10 active Core Committers, and 12 of them committed code in 2023. Google has 4 people allowed to commit code to WordPress, followed by 10up with 3 Core Committers.
Worth noting that 15 of the 39 active committers come from the US, which represents 38% of the Core Committers squad. Australia, Canada, Italy, Poland and United Kingdom each had 2 committers.
More than 30% of the commits were handled by committers located in the United States, 26% by committers located in Russia, and 19% by committers located in France.
Sponsorship
In 2023, 21.6% of the contributors and 23.1% of the committers indicated that a company sponsors their contributions.
Many thanks to @audrasjb for help collecting the 2023 data and for adding several graphics.
Welcome back to a new issue of Week in CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. Let’s take a look at what changed on TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. between September 4 and October 9, 2023.
Please note that exceptionally and because of personal vacations, this Week in Core issue covers 4 weeks 😊
269 commits
337 contributors
295 tickets created
43 tickets reopened
277 tickets closed
TicketticketCreated for both bug reports and feature development on the bug tracker. numbers are based on the Trac timeline for the period above. The following is a summary of commits, organized by component and/or focus.
Welcome back to a new issue of Week in CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. Let’s take a look at what changed on TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. between July 31 and August 14, 2023.
40 commits
50 contributors
164 tickets created
15 tickets reopened
138 tickets closed
TicketticketCreated for both bug reports and feature development on the bug tracker. numbers are based on the Trac timeline for the period above. The following is a summary of commits, organized by component and/or focus.
Code changes
Build/Test Tools
Bump the required versions of Node.js and npm – #56658
Correct two @covers annotations to use the recommended pattern – #59069
Update 3rd-party 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/ Actions – #58867
Update all build tool related dependencies – #58863
Update the README file to reflect new Node.js/npm versions – #59071, #56658
Fix leakage in WP_List_Table tests – #58955, #58896
Code Modernization
Deprecate dynamic properties in WP_List_Table magic methods – #58896, #56034
Deprecate dynamic properties in WP_Text_Diff_Renderer_Table magic methods – #58898, #56034
Deprecate dynamic properties in WP_User_Query magic methods – #58897, #56034
Use “declare” in WP_List_Table magic methods deprecation message – #58896
Coding Standards
Bring more consistency to Last-Modified and ETag checks – #58831
Rewrite loose comparison in wp_list_categories() – #58831
Use instanceof keyword instead of the is_a() function – #58943
Use strict comparison in wp-admin/includes/class-wp-importer.php – #58831
Use strict comparison in wp-includes/class-wp-image-editor.php – #58831
Use strict comparison in wp-includes/class-wp.php – #58831
Use strict comparison in wp-includes/cron.php – #58831
Use strict comparison in wp-includes/kses.php – #58831
Use strict comparison in wp-includes/revision.php – #58831
Docs
Correct duplicate hook reference for wp_min_priority_img_pixels – #59067
Remove @see references for SimplePie classes – #59030
Editor
Only exclude auto-generated 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. files from coding standards checks – #50010
Simplify usage of block_has_support() function by supporting a string – #58532
Embeds
Modernize wp-embed script with removal of obsolete IE10/IE11 code and support for WP 4.4 and below – #58974
Emoji
Suppress console errors from sessionStorage usage in sandboxed post embed 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. – #58978, #58472
HTMLHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers.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.
Adjust code styling to 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/’s linter’s preferences – #58918
Simplify logic in wp_get_loading_optimization_attributes() – #58891
Options, 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. APIs
Use defer loading strategy for wp-embed script and move to head (in block themes) – #58931
Site Health
Use PHP_SAPI constant instead of the php_sapi_name() function – #58942
Themes
Avoid unnecessary check whether parent template file exists when not using a child themeChild themeA Child Theme is a customized theme based upon a Parent Theme. It’s considered best practice to create a child theme if you want to modify the CSS of your theme. https://developer.wordpress.org/themes/advanced-topics/child-themes/. – #58576
add wp_get_theme_data_template_parts function – #59003
A recent in-depth performance analysis of WordPress core showed that loading translations had a significant hit on a site’s server response time. Given that more than half of all WordPress sites use a language other than English (US), the performance team identified this as an area worth looking into more closely. The team spent the last couple of months exploring this in more detail and the results are now shared in this blogblog(versus network, site) post.
This is merely an analysis of the current i18ni18nInternationalization, 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. system in WordPress with some proposed under-the-hood performance improvements. No decisions have been made on any of these proposals.
Context
Initial benchmarks showed that the median loading time for a localized site can be up to 50% slower than for non-localized sites, depending on which themes and plugins are being used. This was measured using both the wpp-research CLI tool and also a dedicated benchmark environment (as elaborated in the Comparison section towards the end).
The WordPress i18n system is based on gettext, which uses source .po (Portable Object) files and binary .mo (Machine Object) files for storing and loading translations. It is not using the C gettext 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. itself but a custom userland implementation that works without any external dependencies.
In addition to coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. itself, each 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 has its own translationtranslationThe process (or result) of changing text, words, and display formatting to support another language. Also see localization, internationalization. file, which has to be loaded and parsed on every request. Loading and parsing all these translation files is an expensive task.
In the past, various solutions have been discussed and explored to improve the i18n performance of WordPress. A non-exhaustive list:
Use a more lightweight MO parser
Improve translation lookups by using the hash map in MO files (e.g. with DynaMo)
Caching translations in the object cache
Caching translations in APCu (an in-memory key-value store for PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher)
Other more elaborated forms of caching (e.g. per request)
Using the native PHP gettext extension
Use a custom PHP extension to handle the MO file parsing)
Using lazily evaluated translation calls (see #41305 for details)
Using a different file format than .mo files, e.g. plain .php files
For this analysis, many of these solutions were looked at, focusing on their advantages and disadvantages. At the end of this post there is a comparison table with some much needed numbers as well, based on custom-built benchmarks.
Solutions
Solution A: Use different file format
Use a different file format for translations instead of .mo files to avoid the overhead of loading and parsing binary files.
Design considerations
With this solution, translations will be stored in plain .php files returning an associative array of translation strings. Whenever a .php file is available, it will be preferred over the .mo file, which is still used as a fallback. The rest of the architecture remains the same.
When a localized WordPress site downloads language packs from the translate.wordpress.org translation platform, it downloads .po and .mo files containing all the translations. This will be modified to include .php files. GlotPress, which the platform is built on, will be updated to support this new output format. Additionally, WordPress core itself could be modified to generate PHP files whenever they are missing.
In theory, nothing is faster in PHP than loading and executing another PHP file. .json, .ini, or .xml would all be much slower.
Initial benchmarks show consistent significant performance improvements
Relatively trivial to implement
Maintains backward compatibility thanks to graceful fallback
Makes it easier for users to inspect and change translations (no need to compile .po to .mo)
Avoids loading and parsing binary .mo files, which is the main bottleneck
Lets PHP store translations in OPcache for an additional performance benefit
Battle-tested approach in the PHP ecosystem (for example in Laravel)
Caveats and risks
Requires not only changes to WordPress core, but also tools like GlotPress and WP-CLIWP-CLIWP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/https://make.wordpress.org/cli/
Adds maintenance overhead by introducing a new file format on top of the existing one
As shown by the proof of concept, the overhead is minimal
In the long term, .mo support could be deprecated
Security considerations due to essentially executing remotely fetched PHP files
Not really different from downloading plugins/themes from WordPress.org
WordPress considers translations to be trusted
Hosting providers could be blocking PHP execution in wp-content/languages
Could potentially use checksum verifications or static analysis at install time to detect anomalies
Effort and timeline
The proof of concept using PHP files is in a very solid state already. There are also examples for changes to WP-CLI (PR) and GlotPress (PR). This makes it suitable for a feature project to expand testing with very little effort required. Even a core merge would be very straightforward in a relatively short time, potentially already in Q4 2023. The security aspect when using PHP files could be a potential blockerblockerA bug which is so severe that it blocks a release., so it’s important to loopLoopThe Loop is PHP code used by WordPress to display posts. Using The Loop, WordPress processes each post to be displayed on the current page, and formats it according to how it matches specified criteria within The Loop tags. Any HTML or PHP code in the Loop will be processed on each post. https://codex.wordpress.org/The_Loop. in the WordPress security team and hosting providers early on.
More time is required to test other file formats and compare results.
Solution B: Native gettext extension
Use the native gettext PHP extension written in C when available, instead of the custom built-in parser in WordPress.
Design considerations
WordPress has always used a custom MO file parser, because the native gettext extension is not necessarily available on the server. With this solution, the existing system is adapted to use the extension whenever available and falling back to the custom implementation if not.
This has been previously explored in #17268 and implemented in WP Performance Pack and Native Gettext. These implementations can serve as inspiration for the initial design. They all work similarly in that they symlink or copy the translation files to a new directory structure that is compatible with the gettext extension.
As of July 2023, around 66% of all localized WordPress sites have the gettext extension installed, according to information from the WordPress update requests.
Benefits
Significant performance improvements for eligible sites
Initial benchmarks show that loading time and memory usage basically do not differ from non-localized sites
Caveats and risks
The gettext extension is not commonly available
Smaller incentive to implement and lower impact overall
Requires locales to be installed on the server
Servers rarely have many installed locales
Locales often need to be compiled first and take up a lot of space
WordPress on the other hand supports over 200 locales
Potential clashes with the custom locales WordPress supports
For example, locales like pt_PT_ao90, de_DE_formal or roh might not even be supported
Outreach to hosting providers would be necessary
Adds maintenance overhead by essentially adding a second gettext implementation
Poor API
Requires setting environment variables (such as LC_MESSAGES and LANGUAGE), which might not be possible or cause conflicts on certain servers/sites
Requires symlinks or hard file copies
Symlinks might not be possible on the server; copying all translation files means doubling disk usage
Translation files are cached by PHP, thus any translation change requires restarting the web server
There are workarounds such as cache busting using random file names or fstat, however they might not work on all environments
Has not been tested on a wider scale, despite being discussed for years
While there are existing implementations that could be leveraged for this solution, further field testing is required to assess whether the extension actually works under all circumstances. Given the limitations around the poor API and requirements for installing locales, it does not seem like a viable solution at all.
Solution C: Cache translations
Cache translations somehow to avoid expensive .mo parsing.
Design considerations
Cache translations either on disk, in the database, or the object cache to avoid expensive .mo file parsing on subsequent requests. This can be done in a generalized manner or also on a per-request basis to only load translations required for the current URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org.
Many different caching strategies have been explored in various forms in the past, each with their own pros and cons. Some could even be combined. Defining the exact implementation requires further exploration and testing, which warrants its own exploration post.
Benefits
Caching translations after one time .mo parsing potentially improves performance for future requests
Caveats and risks
Caching using persistent object cache (e.g. Memcached, Redis) or APCu:
Not available on most sites, making this not an ideal solution
Availability according to data from WordPress update requests:
Memcached: ~25%
Redis: ~25%
APCu: ~6%
Can potentially significantly increase cache size or exceed cache key limits
Database caching:
Moves the problem from disk reads to database reads
Can potentially significantly increase database size
Alternatively, use sqlite as a cache backend
Untested approach
Available on around 90% of sites
Disk caching:
Not always possible, depending on server environment
Still causes file reads, only with fewer or other files
Multiple cache groups (e.g. per-request or frontend/adminadmin(and super admin) split)
Smarter cache logic to only load translations that are needed for the majority of requests
Can potentially significantly increase cache size
Unlikely that different requests use very different translations
Cache retrieval adds overhead
Exact performance gains depend on implementation method and need to be measured first
No performance gains with cold cache
Cache invalidation logic TBD
Effort and timeline
Given the existing solutions in the ecosystem, the engineering effort itself would not be too big, but the right caching implementation (e.g. disk cache or object cache) needs to be evaluated first.
However, the right caching strategy probably does not exist because of all the different hosting environments. Since it’s unrealistic for core to support multiple types of caching, this solution seems better suited for plugins rather than core.
Solution D: Lazily evaluated translation calls
Use lazily evaluated translation calls to reduce the number of function calls in certain cases, leading to improved performance.
Design considerations
The idea of lazily evaluated translation calls has been first discussed in #41305. It enables avoiding string-specific expensive translation lookups until the translations are actually needed, by passing around proxy objects.
In other words: beyond just-in-time loading of translation files (which WordPress already does), this would add just-in-time lookup of individual strings in the translations. Check out this proof of concept to get a better picture.
It can be integrated essentially in two ways, both of which are explained on the core ticketticketCreated for both bug reports and feature development on the bug tracker.:
Change all translation calls to be lazily evaluated by default
Make this opt-in, either with new function arguments or new functions altogether
Benefits
Reduces the number of translation lookups, in some scenarios drastically
On a regular home page request there are ~60% less translation calls, saving around ~10ms (as measured by XHProf)
As a side effect, solves UXUXUser experience issues such as #38643
Caveats and risks
Depending on implementation this either breaks backward compatibility or risks not gaining enough adoption
Documentation, tooling, and developer education can help mitigate this to a certain extent
Adoption could be done gradually, e.g. starting with an opt-in approach and eventually making it the default
Likely will not have a significant impact on typical frontend page loads, as it’s mostly useful for areas like 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/. schema output, where a lot of translation calls are made without actually using the translations
Needs analysis in more scenarios to measure impact
The REST API schema already has a workaround by using a cache in a static variable
Does not improve situation for actually loading translation files
Initial testing shows that this actually hurts performance due to the additional thousands of proxy objects being created
Effort and timeline
Gradual adoption would mean a multi-year effort to establish lazily evaluated translation calls, while enabling this by default is a significant backward compatibility break that could affect thousands of plugins and themes in the ecosystem. And since it does actually slow down performance in some cases, this solution is not a great candidate for implementation.
Solution E: Optimize/Rewrite existing MO parser
Refactor the existing MO parser in WordPress to be more performant.
Design considerations
Completely overhaul the existing MO translation file parser in WordPress with performance in mind. For example by using Ginger MO, WP Performance Pack, or other existing solutions as a base.
While for instance Altis DXP (Human Made) have actually replaced the existing MO parser with a custom-made PHP extension written in Rust, such an approach is obviously not feasible for core. The new solution needs to be written in userland PHP.
Initial testings with an updated fork of Ginger MO show some noticeable speedups and lower memory usage. It also supports multiple translation files per text domain and multiple locales loaded at once, which could prove beneficial for improving the localeLocaleA locale is a combination of language and regional dialect. Usually locales correspond to countries, as is the case with Portuguese (Portugal) and Portuguese (Brazil). Other examples of locales include Canadian English and U.S. English. switching functionality in WordPress core.
Besides that, plugins like WP Performance Pack and DynaMo have implemented partial lookups using the MO hash table or binary search, avoiding reading the whole file and storing it in memory. That slightly reduces memory usage and performance.
Benefits
Can be used without necessarily introducing another file format
Opens up potential performance enhancements in other areas, i.e. locale switching
Mostly maintains backward compatibility
Caveats and risks
Still a risk of breaking backward compatibility
Effort and timeline
There already is a working proof of concept for this solution, but more testing is required to further refine it and improve its backward compatibility layer. With such an effort being an ideal candidate for a feature pluginFeature PluginA plugin that was created with the intention of eventually being proposed for inclusion in WordPress Core. See Features as Plugins., this could be achieved relatively quickly in a few months.
Solution F: Splitting up translation files
Split translation files from plugins and themes into smaller chunks to make loading them more efficient.
Design considerations
Depending on the project’s size, translation files can be quite big. That’s why WordPress itself uses separate translation files for the admin and everything else, so that not too many strings are unnecessarily loaded.
This strategy could be applied to plugins and themes as well. Either by allowing them to use multiple text domains (which would require developer education and changes to tooling), or by somehow doing this automatically (exact method TBD)
Benefits
Faster loading times due to loading smaller files
Caveats and risks
Risk of breaking backward compatibility
Opt-in approach requires tooling and distribution changes and risks slow adoption
Effort and timeline
Further research is required to evaluate this properly.
Comparison
At first glance, solution A (PHP translation files) is a relatively straightforward enhancementenhancementEnhancements are simple improvements to WordPress, such as the addition of a hook, a new feature, or an improvement to an existing feature. that maintains backward compatibility and shows promising improvements. However, it does not only require changes to core itself, but also to the translation platform. The security aspect remains a risk, although discussing it early on with stakeholders and gathering more testers would help mitigate it.
Leveraging the native gettext extension as in solution B shows stunning results, but the lack of availability and the non-ideal API are a concern. Still, it’s a progressive enhancement that cannot be ignored. Especially since it could pretty much eliminate the need for additional caching as in solution C.
Caching already loaded translations as in solution C does not eliminate the root cause of the i18n slowness, but can speed up subsequent requests. Unfortunately, persistent object caches or APCu are rather uncommon (though we do not have exact data on the former yet, see #58808), and implementing more complex types of caching (e.g. per-request caching) would require significant exploration effort before becoming a viable option.
Lazily evaluated translation calls (solution D) can shave time off translation calls in some situations, but overall actually decrease performance. While it could help solve some actual UX issues in core, the backward compatibility and adoption concerns make it even less of a suitable solution.
Existing plugins like Ginger MO and WP Performance Pack show that the existing MO parser in WordPress can be further improved (solution E).
Benchmarks
Now to the most interesting part: the hard numbers!
These benchmarks are powered by a custom-built performance testing environment using @wordpress/env and Playwright. The environment has been configured with some additional plugins and the PHP extensions required for some of the solutions. Tests have been performed against the 6.3 RCrelease candidateOne of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). by visiting the home page and the dashboard 30 times each and then using the median values.
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
Locale
Scenario
Object Cache
Memory Usage
Total Load Time
en_US
Default
15.60 MB
133.58 ms
de_DE
Default
29.14 MB
181.95 ms
de_DE
Ginger MO (MO)
19.24 MB
159.18 ms
de_DE
Ginger MO (PHP)
16.98 MB
138.14 ms
de_DE
Ginger MO (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.)
19.24 MB
153.39 ms
de_DE
Native Gettext
15.99 MB
142.12 ms
de_DE
DynaMo
19.62 MB
157.93 ms
de_DE
Cache in APCu
50.37 MB
181.51 ms
en_US
Default
✅
15.67 MB
121.53 ms
de_DE
Default
✅
29.01 MB
167.67 ms
de_DE
Ginger MO (MO)
✅
19.11 MB
147.19 ms
de_DE
Ginger MO (PHP)
✅
16.85 MB
127.97 ms
de_DE
Ginger MO (JSON)
✅
19.11 MB
144.43 ms
de_DE
Native Gettext
✅
15.86 MB
129.19 ms
de_DE
DynaMo
✅
18.57 MB
133.46 ms
de_DE
Cache in APCu
✅
50.30 MB
170.19 ms
de_DE
Cache in object cache
✅
29.07 MB
173.19 ms
Benchmarks using the Twenty Twenty-Three block theme
Classic Theme
Locale
Scenario
Object Cache
Memory Usage
Total Load Time
en_US
Default
15.35 MB
120.79 ms
de_DE
Default
28.79 MB
172.10 ms
de_DE
Ginger MO (MO)
18.85 MB
145.68 ms
de_DE
Ginger MO (PHP)
16.56 MB
124.73 ms
de_DE
Ginger MO (JSON)
18.84 MB
140.78 ms
de_DE
Native Gettext
15.58 MB
128.26 ms
de_DE
DynaMo
19.24 MB
146.09 ms
de_DE
Cache in APCu
50.13 MB
167.28 ms
en_US
Default
✅
15.19 MB
107.26 ms
de_DE
Default
✅
28.59 MB
154.30 ms
de_DE
Ginger MO (MO)
✅
18.64 MB
133.21 ms
de_DE
Ginger MO (PHP)
✅
16.37 MB
112.94 ms
de_DE
Ginger MO (JSON)
✅
18.64 MB
128.94 ms
de_DE
Native Gettext
✅
15.38 MB
115.11 ms
de_DE
DynaMo
✅
18.10 MB
120.72 ms
de_DE
Cache in APCu
✅
49.99 MB
151.82 ms
de_DE
Cache in object cache
✅
28.65 MB
156.36 ms
Benchmarks using the Twenty Twenty-One classic theme
Admin
Locale
Scenario
Object Cache
Memory Usage
Total Load Time
en_US
Default
15.42 MB
139.83 ms
de_DE
Default
31.92 MB
187.76 ms
de_DE
Ginger MO (MO)
20.07 MB
164.94 ms
de_DE
Ginger MO (PHP)
17.09 MB
139.66 ms
de_DE
Ginger MO (JSON)
20.06 MB
160.87 ms
de_DE
Native Gettext
15.95 MB
143.43 ms
de_DE
DynaMo
20.58 MB
166.79 ms
de_DE
Cache in APCu
58.13 MB
190.38 ms
en_US
Default
✅
15.66 MB
112.69 ms
de_DE
Default
✅
31.84 MB
164.26 ms
de_DE
Ginger MO (MO)
✅
19.99 MB
140.70 ms
de_DE
Ginger MO (PHP)
✅
17.01 MB
118.52 ms
de_DE
Ginger MO (JSON)
✅
19.98 MB
138.49 ms
de_DE
Native Gettext
✅
15.87 MB
120.01 ms
de_DE
DynaMo
✅
19.73 MB
120.26 ms
de_DE
Cache in APCu
✅
58.07 MB
162.41 ms
de_DE
Cache in object cache
✅
31.86 MB
164.28 ms
Benchmarks visiting the WordPress admin
Conclusion
Finding the right path forward means weighing all the pros and cons of each solution and looking at both horizontal and vertical impact, i.e. how much faster can i18n be made for how many sites.
When looking at all these factors, it appears that a revamped translations parser (solution E) could bring the most significant improvements to all localized WordPress sites. Especially when combined with a new PHP translation file format (solution A), which Ginger MO supports, the i18n overhead becomes negligible. Of course the same risks associated with introducing a new format apply.
On top of that, a revamped i18n library like Ginger MO could also be combined with other solutions such as caching or dynamic MO loading to potentially gain further improvements. However, those routes have yet to be explored.
Next steps
The WordPress performance team wants to further dive into this topic and test some of the above solutions (and combinations thereof) on a wider scale through efforts like the Performance Lab feature project. We are looking forward to hearing your feedback on this analysis and welcome any additional comments, insights, and tinkering.
Deadline August 6, 2023
After the deadline passes, the performance team will discuss the received feedback and determine next steps.
Welcome back to a new issue of Week in CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. Let’s take a look at what changed on TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. between June 19 and July 3, 2023.
88 commits
143 contributors
87 tickets created
19 tickets reopened
115 tickets closed
TicketticketCreated for both bug reports and feature development on the bug tracker. numbers are based on the Trac timeline for the period above. The following is a summary of commits, organized by component and/or focus.
Code changes
Build/Test Tools
Improve the name of the e2e test jobs on 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/ Actions – #58661
Run E2E tests with and without SCRIPT_DEBUG enabled – #58661
Switch frame container when testing 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. editor output – #58592
Switch frame container when testing block editor output – #58592
Update terser-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 – #58660, – #57657
Bundled Themes
Twenty Fourteen: Fix text color issue on Button block hover – #58509
Twenty Nineteen: Add fragment ID to paginated links – #45920
Twenty Nineteen: Always set background color and foreground color together – #45916
Revert use of str_starts_with() and str_contains() in update-core.php – #58206
Database
Move the if statement outside of the 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.. – #56541
Docs
Correct @return description for wp_count_posts() – #58685
Revert unnecessary changes to .jshintrc files – #12009
Update block-serialization-default-parser package for WP 6.3 BetaBetaA pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 1 – #57832
add 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. around post editor – #58626
add navigation fallback – 58557
adds deprecation for deleted block_core_navigation_submenu_build_css_colors function – #58623
refactor and stabilize selectors 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. – #58586
stabilise layout and refactor definitions – #58550
update npm packages to latest 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. versions – #58654
update npm packages with 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 and blessed tasks – #58701
Emoji
Give name to web worker in emoji loader and terminate when finished – #58472
Optimize emoji loader with sessionStorage, willReadFrequently, and OffscreenCanvas – #58472
Pass functions as arguments in loader to account for minification and worker script – #58472
Filesystem API
Allow optional inclusion of hidden files in list_files() – #53659
Define password as null if not set when using SSH2 with public/private key – #33196
General
Add missing parentheses to functions referenced in _deprecated_function() calls added in 6.3 – #58235, #58301, #58555
Ignore 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. types for the ‘_wp_http_referer’ URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org query variable – #57670
HTMLHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. API
Fix a fatal error when processing malformed document with unclosed attribute – #58637
Declare a few default parameters in WP_Http_Curl and WP_Http_Streams – #52622
Media
Fix inconsistent docs for existing wp_img_tag_add_loading_attrfilterFilterFilters 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. and remove duplicate – #58235
Only show “Copy” and “Download” actions when an attachment URL is available – #57893
Menus
Allow themes and plugins to pass HTML attributes to various Nav Walker outputs – #57140
Options, 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. APIs
Check if the gmt_offset value is numeric in sanitize_option() – #57728
Prime networknetwork(versus site, blog) options in a single cache call using wp_cache_get_multiple – #56913
Add an action hook to bulk_edit_posts() function – #28112
Ensure scheduled posts are published when using Bulk Edit – #31635
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/.
Cache schema in block pattern and menu item endpoints – #58657
Check post meta update authorization only when value is changed
Expose current $request object to cors_header filters in WP_REST_SERVER->serve_request() – #57752
add 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. endpoint for global styles – #58524
Correct the label for wp-content directory check – #58678
Include new WP_DEVELOPMENT_MODE in the list of constants – #58646
Themes
Block template is located twice in get_query_template() – #58299
Fix layout issue on the Themes page background overlay – #58164
Use get_theme_file_path() in wp_theme_has_theme_json() – #57629
Use improved support for child themes in wp_theme_has_theme_json() – #57629
Upgrade/Install
Initialize the local $checkout variable in WP_Automatic_Updater::is_vcs_checkout() – #58563
Only show errors if there is nothing to update – #57999
Pass the full database version string to 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/ for parsing – #58584
Welcome back to a new issue of Week in CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. Let’s take a look at what changed on TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. between June 19 and June 26, 2023.
112 commits
192 contributors
68 tickets created
16 tickets reopened
107 tickets closed
TicketticketCreated for both bug reports and feature development on the bug tracker. numbers are based on the Trac timeline for the period above. The following is a summary of commits, organized by component and/or focus.
Code changes
Administration
Add the no-store and private directives to the Cache-ControlheaderHeaderThe 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 preventing caching for logged in users – #21938, #57627
Backwards compatibility for new sortable keys – #32170
Consistent positioning and size of search form – #57949
Fix visual 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. in media search input – #57949
Reduce translationtranslationThe process (or result) of changing text, words, and display formatting to support another language. Also see localization, internationalization. calls after [55969] – #57675
Replace Tagline option placeholder with a description – #57675
Replace contracted verb forms for better consistency – #30796
Set accessible state for list table headers – #32170
Bootstrap/Load
Require wp-includes/compat.php earlier in wp-settings.php – #58206
Require wp-includes/compat.php in wp-load.php – #58206
Update URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org of theme unit testunit testCode written to test a small piece of code or functionality within a larger application. Everything from themes to WordPress core have a series of unit tests. Also see regression. data – #58569
Update the test for pre_wp_setup_nav_menu_itemfilterFilterFilters 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. – #56577
Bundled Themes
Twenty Fifteen: Fix Letter Case implementation – #58526
Twenty Fifteen: Remove IE specific resources – #56699
Twenty Fourteen: Fix Letter Case implementation – #58526
Twenty Nineteen: Always set background color and foreground color together – #45916
Twenty Nineteen: Ensure Separator 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. supports theme colors in editor – #58558
Twenty Nineteen: Fix a JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. coding standard issue found after [55970] – #46474
Twenty Nineteen: Prevent a console error related to the main navigation on Firefox – #46474
Twenty Nineteen: Remove unused function parameters and variables – #57397
Twenty Twenty: Fix Letter Case implementation – #58526
Twenty Twenty: Fix an RTL style issue leading to failed Test Default Themes & Create ZIPs workflow – #58396
Twenty Twenty: Fix left margin in Latest Posts & Latest Comments blocks – #58396
Twenty Twenty: Inherit Quote block’s paragraph custom letter spacing in the editor – #58033
Twenty Twenty: Remove various unused function parameters and variables – #57371
Twenty Twenty: Revert [56034] pending further investigation – #58396
Cache 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.
Remove unused usermeta global cache group – #58175
Code Modernization
Replace usage of strpos() with str_contains() – #58206
Replace usage of substr() with str_starts_with() and str_ends_with() – #58220
Fix block editor styles being registered with frontend stylesheets – #58605
Fix block template utils test: use template part instead of template object – #58540
Improve 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) of new 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.UIUIUser interface – #15631
Introduce WP_Theme_JSON::prepend_to_selector() to improve code quality and performance – #58193, #58457
fix site editor layout 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. – #56228
Improve Dashboard screen options behavior on small screens – #57977
I18Ni18nInternationalization, 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.
Ensure determine_locale() does not potentially return an empty string – #58317
Add a $previous_status parameter to wp_trash_post() related 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. – #58392
Quick/Bulk Edit
Don’t set publish date when editing drafts – #19907
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/.
Indicate when a theme supports the Site editor in the Themes REST API response – #58123
Return post modified datetime for Templates – #58540
Script Loader
Add support for HTMLHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. 5 “async” and “defer” attributes – #12009
Replace str_contains() usage in wp-includes/script-loader.php – #58206
Themes
Allow non-block themes to add theme support for border settings – #58598
Allow non-block themes to add theme support for link color settings – #58597
Change the order of path check in is_block_theme method – #58520
Fix caching issue in get_post_templates method in WP_Theme – #57886
Tools
Fix unresolvable conflicts computation in package sync script – #58628
Upgrade/Install
Add aria-describedby for input descriptions – #58613
Move location of $upgrade_notice for better consistency – #57939
Prevent users from sending multiple bulk 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 updates – #40966
Welcome back to a new issue of Week in CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. Let’s take a look at what changed on TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. between June 12 and June 19, 2023.
41 commits
61 contributors
66 tickets created
7 tickets reopened
40 tickets closed
TicketticketCreated for both bug reports and feature development on the bug tracker. numbers are based on the Trac timeline for the period above. The following is a summary of commits, organized by component and/or focus.
Fix Twenty Fourteen button blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. line-height – #58444
Remove load_theme_textdomain() calls from default themes – #58318
Twenty Seventeen: Improve Grid View variation rendering in the editor for the Post List block – #58531
Cache 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.
Remove unused usermeta global cache group – #58175
Coding Standards
Use strict comparison in wp-includes/class-wp-list-util.php – #57839
Use strict comparison in wp-includes/class-wp-oembed.php – #57839
Use strict comparison in wp-includes/pomo/entry.php – #57839
Use strict comparison in wp-includes/pomo/mo.php – #57839
Use strict comparison in wp-includes/pomo/streams.php – #57839
Use strict comparison in wp-includes/pomo/translations.php – #57839
Docs
Use third-person singular verbs in various function descriptions, as per docblocks standards – #57840
Use third-person singular verbs in various function descriptions, as per docblocks standards – #57840
Use third-person singular verbs in various function descriptions, as per docblocks standards – #57840
Use third-person singular verbs in various function descriptions, as per docblocks standards – #57840
I18Ni18nInternationalization, 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.
Add support for CSSCSSCascading Style Sheets.repeat() function – #58551
Media
Deprecate the ‘edit_custom_thumbnail_sizes’ 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. and disable the “Apply changes to [Thumbnail|All|All except thumbnail]” UIUIUser interface in the image editor. Add a (boolean) filter to reenable that UI – #57685
Display the “Copy URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org” and “Download file” row actions when the “Unattached” filter is applied – #57890, #57893
Welcome back to a new issue of Week in CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. Let’s take a look at what changed on TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. between June 5 and June 12, 2023.
30 commits
48 contributors
67 tickets created
3 tickets reopened
44 tickets closed
TicketticketCreated for both bug reports and feature development on the bug tracker. numbers are based on the Trac timeline for the period above. The following is a summary of commits, organized by component and/or focus.
Code changes
Administration
Improve alignment in the Activity dashboard widgetWidgetA 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. – #58114
Avoid loading a theme’s functions.php when ! wp_using_themes() – #57928
Bundled Themes
Twenty Twenty-Three: Remove redundant px unit in a few inline styles – #58485
Coding Standards
Use strict comparison in wp-admin/options-writing.php – #57839
Use strict comparison in wp-includes/class-walker-category.php – #57839
Use strict comparison in wp-includes/class-walker-page-dropdown.php – #57839
Use strict comparison in wp-includes/class-walker-page.php – #57839
Use strict comparison in wp-includes/class-wp-http-streams.php – #57839
Use strict comparison in wp-includes/class-wp-list-util.php – #57839
Docs
Fix a few more typos in Docblocks – #58338, #57840
Improve various docblockdocblock(phpdoc, xref, inline docs) in WP_Query class, as per docblock standards – #57840
Mark apply_filters() third parameter $args as optional – #58481, #57840
Various docblock improvements in Custom 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. Image related functions, as per docblocks standards – #57840
I18Ni18nInternationalization, 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.
Provide gettext context to disambiguate various translationtranslationThe process (or result) of changing text, words, and display formatting to support another language. Also see localization, internationalization. strings – #58424
Login and Registration
Grammar improvement on Sign-up user-facing strings – #58115
Media
Fix CSSCSSCascading Style Sheets. layout issues in Replace media dialog – #54395
Networks and Sites
Require a site title when a site is created – #54012
Plugins
Display Auto-updates filters when the current view is “Must Use” or “Drop-in” – #54309
Query
Allow queries by wp_dashboard_recent_posts() to be cached – #57055
Script Loader
Add a check to see in style is registered in wp_maybe_inline_styles – #58394
Improve performance of wp_maybe_inline_styles function – #58394
Themes
Replace file_exists checks with call to is_block_theme method in WP_Theme class – #58405
Upgrade/Install
Improve WP_Upgrader strings rendering on small screens – #58477
Users
Use type="hidden" for hidden input on User edit administration panel – #56776
XML-RPC
Update RSD specification URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org in XMLRPC library – #58503
Welcome back to a new issue of Week in CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. Let’s take a look at what changed on TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. between May 8 and May 22, 2023 (sorry for not being able to publish a post last week, this one will cover two weeks!).
TicketticketCreated for both bug reports and feature development on the bug tracker. numbers are based on the Trac timeline for the period above. The following is a summary of commits, organized by component and/or focus.
Code changes
Administration
Add missing escaping for CSSCSSCascading Style Sheets. classes on the body tagtagA 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 the adminadmin(and super admin) – #58336
Build/Test Tools
Call wp_cache_flush_runtime in WP_UnitTestCase. – #31463
Move wp_cache_flush_runtime() next to wp_cache_flush() – #57841
Remove expectation of a deprecation notice from WP_Posts_List_Table tests – #58157
Split the tests from user/author.php into individual test classes – #57841
Use the function get_num_queries across all unit tests – #57841
Code Modernization
Correct fallback return value in get_the_author() – #58157
Explicitly declare all properties in Text_Diff_Engine_native – #58298
Coding Standards
Use esc_url() to escape link URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org value in wp-admin/edit-link-form.php – #58282
Comments
Always lazily load comment 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. – #57801
Docs
A host of corrections and improvements to inline documentation – #57840
Clarify @param types on get_sample_permalink_htmlfilterFilterFilters 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. – #58322
Correct default value for the $optimize option in Style Engine – #57840
Fix a few more typos in DocBlocks and inline comments – #57840
Fix a few more typos in inline comments – #58334, #57840
Fix typo in a comment in Bulk_Upgrader_Skin::header() and ::footer() – #58334
Improve HTMLHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers.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. file and class headers per the documentation standards – #57840
Improve Style Engine DocBlocks per the documentation standards – #57840
Improve Style Engine file and class headers per the documentation standards – #57840
Improve a few DocBlocks in wp-includes/formatting.php – #58316
Update code examples formatting in WP_HTML_Tag_Processor documentation – #58028
Various corrections and improvements to inline docsinline docs(phpdoc, docblock, xref) and docblocks – #57840
describe return type of _get_block_template_file() – #57756
Editor
Disable lazy loading term meta in get_block_templates – #58230
Ensure 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. comments are of a valid form
Remove 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. support from block templates
Restore shortcode support for block templates – #58333
Update block editor packages to the latest 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. releases – #58274
Embeds
Add protocol validation for WordPress Embed code
General
Remove a few is_object() checks followed by instanceof operator – #58309
Use static on closures whenever $this is not used to avoid memory leaks – #58323
Help/About
Remove unwanted space in a link located on about.php – #58373
I18Ni18nInternationalization, 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.
Introduce sanitization function for localeLocaleA locale is a combination of language and regional dialect. Usually locales correspond to countries, as is the case with Portuguese (Portugal) and Portuguese (Brazil). Other examples of locales include Canadian English and U.S. English.
Replace “Roll back” with “Restore” in user facing strings – #58282
Media
Conditionally skip lazy-loading on images before the 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. to improve LCP performance – #58211
Increase default for wp_omit_loading_attr_threshold to 3 – #58213
Load WP_Metadata_Lazyloader class file if class does not exist – #58185
Load WP_Metadata_Lazyloader class file if class in meta.php – #58185
Plugins
Remove is_object() check in WP_Hook:build_preinitialized_hooks() – #58290
Posts, Post Types
Add a new filter for query arguments in get_pages – #12821
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 edit link functionality for the wp_template and wp_template_part post types – #57709
@bph ran a lively meeting from a simple agenda (and a new continent!): • Site updates and news • Project Board ◦ In the works ◦ Reviews needed ◦ To be approved ◦ New discussions on topics • Open Floor
Site updates and news
@bph has moved from Sarasota, FL, USA to her hometown—Munich, Germany—after 25 years in the States.
More exciting than her big move was her news about the blogblog(versus network, site). She’s been working with @dd32 on a few things:
Working on the blog adds goodies to your .org profile
Dion has installed 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/’s WP Activity Notifier 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, which adds a post contribution to your WordPress.org profile activity list every time you publish a post, going forward. The contribution looks like this:
If you wrote an article between November and now, he has added the activity to your profile retroactively, by hand. Thanks, @dd32!
Let’s build a Create Props 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.!
Since all the Make blogs are adding props for review, Dion has also started thinking about a Props block for posts and whatever else. If you have some time to make this real, he and Birgit have opened a 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.ticketticketCreated for both bug reports and feature development on the bug tracker.#6945 with their thoughts on how to get started.
Cross-publishing dev blog posts in CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. and dev-blog SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/. channels
Addressing a Dev chat conversation with@jeffpaul, Birgit and Dion have also made every new post on the dev blog auto-publish on the Core Slack as well as the #core-dev-blog Slack. So that should get even more eyes on the blog!
A 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/ organization for educational code
Birgit told the group that @psykro is working through a process that will make a GitHub organization for the faculty on the Training team and dev-blog authors to house code people can learn from. More on this when there is news to report …
@bph pointed out that some of those are delayed because of travel, or are waiting for a feature to land in a stable release 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/, Core or a feature pluginFeature PluginA plugin that was created with the intention of eventually being proposed for inclusion in WordPress Core. See Features as Plugins.. Or, she added, because the writers don’t yet have the bandwidth.
@greenshady noted that a lot of those ideas are his, and he’s happy to write any or all of them. The one post he is firmly committed to writing himself is the tutorial on the Details/Summary block.
The group spent a few minutes discussing what block governance really means in idea #2 and concluded that the post covers restricting access to specific block controls by user role so authors and editors on a WordPress site—maybe a publication or a corporate site, for instance—can edit content and visuals but can only use blocks that are styled to comply with their company brand standards.
@marybaum noted she can start the typography series in idea #6 this week with a plan for the posts and a draft of the first one.
Welcome Olga!
@bph welcomed @oglekler to the meeting and the editorial board. Recommended by @webcommsat (and highly seconded by your friendly neighborhood summary writer) Olga Glekler is a full-stack developer, component maintainer, and contributor to several Make teams over the years. The group gave her a rousing, emoji-filled welcome.
Open floor
@webcommsat suggested that whoever writes the agenda distribute links ahead of time so attendees can come prepared to discuss an idea at a deeper level come meeting time. Several folks thought that was a nice idea and then admitted they might not actually get around to reading the material in advance.
Birgit raised Olga’s post in the dev-blog Slack about software architecture and how to keep basic principles in mind as developers switch from language to language. The group concurred that a discussion of these concepts would be immensely valuable, as long as they stay firmly rooted in WordPress-relevant examples.
You must be logged in to post a comment.