Speculative Loading, or A Brief History of Landing a Performance Feature in WordPress Core

Two years ago today, on May 22, 2023, I opened an experimental pull request for a new module in the Performance Lab plugin. That little experiment was the very first step on a long road that ultimately led to the “Speculative Loading” feature landing in WordPress 6.8 last month (April 2025).

For those unfamiliar, the Speculative Loading feature enhances performance by speculatively loading pages a user is likely to visit next, which can make navigation feel almost instantaneous. If you want to dive into the technical nitty-gritty, I recommend checking out the “dev note” post on Make WordPress Core.

This post, however, isn’t about the what or how of the feature itself. Instead, I want to pull back the curtain and share the story behind the feature—the milestones, the discussions, and the collaborative effort that took it from a spark of an idea to a reality for millions of WordPress sites. The impact is considerable even for the entire web. Keep reading to the end for concrete numbers. 👇

The Spark: An Intriguing Browser API

It all began on April 20, 2023, when an internal Google email thread about preloading techniques landed in our team’s inbox. Part of that thread was a slide deck for an upcoming TPAC 2023 presentation by Domenic Denicola and Jeremy Roman, who were deeply involved in a new browser-level API called Speculation Rules API.

Learning about this API, I was immediately excited. The potential performance benefits for the web, including for WordPress, seemed enormous. What particularly caught my eye were “document-level rules”, which went beyond loading specific URLs to opting in to loading entire URL patterns (as detailed later in this Chrome developers blog post). At that time, this aspect of the API was truly cutting-edge. It required Chrome 113 (which was just about to be released on April 26, 2023) and, crucially, opting into a Chrome origin trial because it was such an early feature. Naturally, I signed up straight away.

First Steps: Pull Request for an Experimental Module

A few weeks of mulling it over passed, and then on May 19, 2023, I finally decided to dive in and explore how this API could work within WordPress. This led to the creation of that first experimental pull request three days later, on May 22nd.

I shared this initial exploration both with my colleagues at Google who were working on the browser API itself and with the broader WordPress Performance Team. The idea was met with a good deal of curiosity and excitement, though everyone acknowledged its experimental nature. The browser API was still very young, and its reliance on an origin trial meant it wasn’t something we could roll out widely.

The feedback on the pull request was super helpful, coming from both the Google side and WordPress contributors. We got the pull request into a pretty decent shape so that it could in principle be added to Performance Lab, but it remained an exploration. The WordPress Performance Team had many other priorities, and as long as the core browser functionality was locked behind an origin trial, it didn’t make sense to push too hard on a plugin that very few could actually use.

Gaining Momentum: Browser API Maturation

Time marched on, and then in early November 2023, we received some exciting news: the document-level rules for the Speculation Rules API were slated to become publicly available, no origin trial needed, with the release of Chrome 121 on January 17, 2024.

This was a significant development. Around the same time, Chrome had also introduced DevTools features to help debug speculation rules, and more comprehensive documentation was starting to appear, including on MDN.

This news was the catalyst to get serious about the dormant pull request. I revisited it, updated it to align with the latest WordPress Core changes that had happened in the meantime, and began polishing it towards a Minimum Viable Product (MVP).

On November 20, 2023, I created a new feature branch for the prospective “Speculation Rules” module within the Performance Lab plugin. We opted for a feature branch because:

1. We needed to ensure that even if the initial PR was merged, the module wouldn’t be released until the browser API was widely available without the origin trial.
2. We anticipated a few follow-up pull requests to build out the full MVP.

Following further discussions with fellow WordPress Performance Team contributors, I formalized the idea by opening a module proposal issue on December 5, 2023. This provided a comprehensive overview of the feature and its intended scope.

First Release of the Plugin

Things started moving quickly then. That initial pull request, which had evolved from an experiment to a serious feature implementation, was finally merged on December 15, 2023! I immediately opened a follow-up issue to track the remaining tasks before our first public release.

A few relatively straightforward follow-up pull requests (#938, #939, #940) were implemented and merged by mid-January 2024. Concurrently, the WordPress Performance Team was finalizing its annual roadmap, and “speculative prefetching and prerendering” (as we often called it then) earned its place as a priority project. You can see it listed on the 2024 roadmap here.

Meanwhile, a significant holistic discussion had unfolded regarding the structure of the Performance Lab plugin. The decision was made to decouple its modules into individual, standalone plugins. Performance Lab would continue as an optional central orchestrator, but users could also install specific performance features independently. This required a migration effort of the existing modules into plugin shape. I opened a pull request (#946) on January 17, 2024, to transition the Speculation Rules module into its own plugin. On that very same day, we submitted this nearly complete plugin to the WordPress plugin directory.

The review process by the WordPress plugin team was incredibly swift, and the plugin was approved a day later (a huge thank you to them!). While the migration pull request (#946) hadn’t technically been merged yet, all the core code was complete and approved. Therefore we decided to push the release so users could start testing almost immediately after Chrome 121 had just made the browser API widely available. Another day later, on January 19, 2024, the 1.0.0 version of the Speculation Rules plugin launched on WordPress.org. This was a major milestone. Despite that, we kept promotion low-key initially, as a few more enhancements were planned.

On a personal note, just a few days later, on January 24, 2024, I experienced an even more significant milestone: I became a dad! 👶 As such, I went AFK for a while, enjoying this precious time with my new family. Thankfully, the Speculation Rules plugin was in the capable hands of my teammates at Google and the other WordPress Performance Team contributors – a special shoutout to Weston Ruter, who has been instrumental in polishing and helping shepherd the feature all the way until stable.

Introducing “Speculative Loading”: Promotion and Gaining Traction

On February 16, 2024, version 1.0.1 of the Speculation Rules plugin was released with some bug fixes. Perhaps more importantly, this coincided with the Performance Lab 2.9.0 release, which officially added our plugin to its list of associated plugins. This significantly broadened its promotion due to Performance Lab’s widespread adoption.

When I returned from my initial parental leave about ten days later, the Speculation Rules plugin was already active on over 500 WordPress sites! Not a massive number in the grand scheme of WordPress, but impressive for a plugin barely a month old.

Over the following months, we continued to polish the plugin, shipping further enhancements and bug fixes, and promoting it more widely. During this period, the WordPress Performance Team undertook a project to revise plugin names, aiming for clarity by focusing on user-facing benefits rather than underlying technologies. As part of this initiative, the “Speculation Rules” plugin was renamed to the “Speculative Loading” plugin (see the renaming pull request #1101).

Following these enhancements, the new name, the maturation of the browser API, and encouraging feedback from other browser vendors (see Mozilla’s standards position and WebKit’s standards position), I collaborated with other contributors to publish a Make WordPress Core blog post on April 9, 2024. This shared the project more broadly with the WordPress developer community.

An important decision made early in the plugin’s development was to default to prerendering with “moderate” eagerness. This is a more “aggressive” setting (offering better performance but potentially more resource-intensive) than what we ultimately shipped in WordPress 6.8. It was a deliberate choice for the plugin, as it allowed us to gather feedback on a more impactful version of the feature from a performance perspective. For WordPress Core, however, we would later opt for a more conservative default (prefetching with “conservative” eagerness) to ensure resourcefulness at scale.

The Road to Core: Gathering Evidence and Formal Proposal

Both the Speculative Loading plugin and the underlying Speculation Rules browser API continued to gain traction. Six months after that Make Core post:

• The plugin had amassed over 40,000 active installations and maintained exclusively 5-star ratings on the WordPress plugin directory.
• Cloudflare enabled speculative loading for their users, reporting a “reduction in LCP of 45% on successful prefetches.”
• Further partnership experiments between Google and companies like Shopify continued to demonstrate the feature’s positive impact on load times and user experience.
• The Speculation Rules API itself was already being used on over 8% of Chrome page loads.

With such positive signals, even at a considerable scale, it felt like the right time to formally propose the feature for inclusion in WordPress Core. On November 21, 2024, I opened a WordPress Trac ticket (#62503) proposing the feature for WordPress 6.8. Alongside it, I submitted a WordPress Core pull request (#7860) with the proposed code, which was largely a port of the existing plugin.

As mentioned, while the plugin used “prerender” with “moderate” eagerness, we opted for a more conservative approach (literally!) for Core, using only “prefetch” with “conservative” eagerness. At the massive scale of WordPress (impacting over 40% of the web), this was a safer starting point. The implementation, however, was designed to potentially allow for adjustments in the future as the browser API evolves or as confidence in other configurations grows.

The Final Push: Community Feedback and Commitment

For the next two months, the Trac ticket and pull request primarily saw feedback from contributors already involved in the development. While valuable, a feature of this significance ideally receives broader input from the wider WordPress Core community, including experienced long-term contributors and committers. In mid-January 2025, we began to more actively solicit this feedback, raising the ticket during the weekly WordPress Core “dev chat” and eventually bumping its priority on Trac.

Aside: It’s not uncommon for Trac tickets to only receive broader feedback later in the process. This isn’t ideal, but it’s often a reality given the limited resources and the sheer volume of ongoing development efforts. Reviewing a notable feature thoroughly takes time, which is a scarce commodity for many contributors. If you want to help, consider sponsoring WordPress development.

By early February, we started seeing more engagement from other long-term contributors. This sparked some excellent discussions on the Trac ticket, the pull request, and synchronously on Slack. Some conversations worth highlighting include this Slack discussion, this Trac ticket discussion, and this GitHub pull request discussion.

Both general considerations and specific technical details were debated, and much of the final fine-tuning of the implementation occurred during this “final sprint”, which took about three weeks. Eventually, the pull request garnered several approvals, and a consensus emerged that the feature was ready for WordPress Core.

And so, on February 18, 2025, I committed the feature to WordPress Core! This was a good two weeks before the WordPress 6.8 Beta 1 release was due – a critical deadline, as new features and enhancements must be committed before the first Beta of a release cycle.

Post-Commit and Launch

A small follow-up fix was committed a few days later, but overall, the period following the commit was quiet – exactly what you hope for! It indicated no significant issues with the feature, especially during the Beta and Release Candidate (RC) periods.

While monitoring post-commit feedback, I began working on the “dev note” – the official Make WordPress Core blog post that describes a new Core feature for developers, explaining how it works and how it can be customized. Writing such a post is a crucial step to inform the WordPress developer ecosystem about upcoming changes, for example allowing plugin developers to prepare their plugins. Several other WordPress Core Performance Team members collaborated on it, and the post was published on March 6, 2025. This is likely the post many of you read if you were already familiar with Speculative Loading in WordPress 6.8.

And that was it! Nearly two years after the work had started, the Speculative Loading feature officially launched as part of WordPress 6.8 on April 15, 2025.

Post-Launch: Impact Metrics time!

Now that the feature is out there, the final step is to assess its real-world impact. It is great to see the adoption impact already:

• From March 2025 to May 2025, usage of the Speculation Rules API for all navigations (individual page loads) across the web grew from 8.47% to 10.81%, a relative increase of 27.63%!
• From March 2025 to May 2025, usage of the Speculation Rules API for all origins (entire websites) across the web grew from 0.39% to 18.09%, a relative increase of 4538.46%! 🤯

Data based on public Chrome datasets. Please refer to this Colab for the full data.

The data strongly suggests that the majority of the feature usage growth across the overall web comes from the WordPress 6.8 launch, because of WordPress’s large scale and the fact that in the preceding months the feature usage growth was more or less flat. So that’s an amazing win and goes to show once again the impact that WordPress has on the entire web!

That said, usage is only a secondary metric. For a performance feature like speculative loading, we ideally want to get an idea on the performance impact of the feature, in particular on LCP. For this, we will need to wait for May data for the Chrome User Experience Report (CrUX), which is slated to become available in mind-June. I am looking forward to taking a closer look.

Looking Back

While the technical behavior of speculative loading is becoming more and more well-documented, with this article I wanted to share the story behind how it all came to be. If you have any questions, please feel free to ask them in the comments!

If you are interested in the speculative loading feature’s technical aspects, I recently recorded a WP Tavern podcast episode with a technical deep dive, which should air very soon.

The journey of a WordPress Core feature can be a long and winding road. While the focused development time for the Core commit might appear to be just a couple of months, it’s often preceded by a much longer period of exploration, experimentation, plugin development, and community feedback.

To recap the key milestones for Speculative Loading:

• April 2023: Initial “discovery” of the Speculation Rules API.
• May 2023: First experimental Performance Lab module PR.
• November 2023: News of broader browser API availability; serious development resumes.
• January 2024: Standalone “Speculation Rules” plugin launched on WordPress.org.
• Spring-Summer 2024: Plugin renaming to “Speculative Loading,” and broader promotion, community outreach, and usage growth.
• November 2024: Formal proposal for WordPress Core inclusion.
• February 2025: Feature committed to WordPress Core for version 6.8.
• April 2025: WordPress 6.8 released with Speculative Loading.

Today, exactly two years after that first tentative pull request, it’s incredibly rewarding to look back at this journey and celebrate the successful launch of a feature that I believe will make a real difference to WordPress performance.