It's perilous to disagree with someone as wise and thoughtful as Jeremy, but for the past fortnight his post in response to Apple's iOS 27 marketing invades my quiet moments like a cricket in the attic.

"Why", I ruminate, "should someone who understands the state of play give Apple credit for doing less than the minimum while rubbishing those who have consistently done more?"

Redux

Like Apple's previous marketing of Safari 16.4 and Safari 26, the conjoined September release of Safari and iOS 27 documents an achingly slow release cycle. It would be one thing if the features or spec conformance were world-beating, but looking closely at the release notes, Safari 27 is set to deliver fixes for issues that, by and large, competing engines didn't suffer.¹

Don't get me wrong: it's great that Apple is focusing on quality; it remains a persistent issue for Safari. But how much relief should long-suffering web developers expect?

The best comparative measures come from the communal Web Platform Tests project. Comparing the current experimental builds with stable channel releases can illuminate the scale of change we can expect when the next major version of each browser launches:²

It would appear that Safari is closing on Firefox, but this is slightly misleading, as Mozilla's monthly release cycle is significantly shorter. Apple managed seven releases over the past year, or a roughly eight week cadence. Mozilla and Chromium, meanwhile, have released 12 versions to stable, or one a month. These serve as denominators (7.4 weeks vs. 4.3) when calculating rates of improvement. Safari's larger increase in passing tests between nightly and stable versions (1558 vs. 990 for Firefox) looks large, and Apple wants us to think that's down to renewed focus. But this is a statistical mirage. On a time-weighted basis, Safari continues to improve more slowly than Firefox, logging 207 improved tests per week since the last stable release versus Firefox's 230 and Chromium's 460.

But is that focus on this most recent release misleading? Looking across a longer time period can help us level-set. WPT is very flexible, and anyone can construct a query like this, comparing developer channel releases of each engine at this point last year to the current build:

Note that the total number of tests in the corpus is not fixed; because new features are constantly added to browsers, the denominator continues to increase over time. It's helpful, then, to look at the change in tests passing as a fraction of all tests over time. This gives us a sense if an engine is progressing (or regressing) relative to the web's potential:

Total test pass rates imply the role of engines as the blockers of widespread compatibility, but aren't a foolproof indicator. For example, if every engine failed the same way, it would be regrettable, but compatible. Web developers wouldn't have cause to throw shade at one browser more than others, so perhaps overall test failure rates obscure more than they clarify?

Helpfully, wpt.fyi also generates charts for tests that fail in just one engine. But for bugs unique to that codebase, the web would be more capable and less costly to develop for. The higher the count, the more an engine holds back progress:

At the time of writing, WebKit nightlies are alone in failing ~4,200 tests, Gecko is next at ~2,400, and Blink is the least incompatible with just under 800 unique failures. These relative rates have remained stable across many years, indicating higher sustained investment in Blink and Gecko versus WebKit.

Including the test262 JavaScript conformance suite, we see a huge spike in WebKit-exclusive test failures. This is thanks to Blink and Gecko shipping the new Temporal API this spring. Temporal has been in development for nearly a decade; it hardly snuck up on Cupertino. Judging by the Safari 27 blog post, and confirmed by the state of the nightly test runs, it will not be included when new features ship in September.

Apple has repeatedly claimed to regulators that there's no need for real choice in iOS browsers because Safari is more than capable and the team is well funded. It's unclear how those claims can be squared with such an embarassing showing on a long-anticipted feature that Apple has no objection to.

Features Over Tests

One critique raised by this visualisation is that tests are not features. Some areas (like Temporal) include exhaustive test suites with many sub-tests, driving up their relative numbers. Other features may be foundational or internally complicated, but may have proportionally fewer WPT tests.

Thankfully, webstatus.dev has collated a feature-oriented view of the same data. Looking across the past decade, it shows that WebKit is the predominant reason features remain unavailable to users and developers, forcing both into the App Store where Apple demands a 30% cut:

Looking at large, heavily tested, uncontroversial areas of the platform shows that the gap isn't simply down to features that Apple thinks are problematic; even in areas where Cupertino is fully engaged, it frequently trails:

Remember that Mozilla makes something in the range of $500MM/yr from all revenue sources and spends the vast majority of that on browser development. Apple, meanwhile, rakes in more than $20BN per year from its web search deal with Google, or 40x as much. Stable Firefox passes 84.9% of CSS tests, while Safari clears 86%, or a 1.1% difference:

Results from nightlies suggest that Safari 27 will widen Apple's lead versus Firefox to 1.6%, while trailing both Stable and Canary versions of Chromium (93.4% and 95.5%, respectively). Improvement is improvement, but Apple's layout engine remains riddled with O(n^2) behaviours. Both Mozilla and the Chromium community funded multi-year rearchitecture projects improve performace in this area, but Apple has not made similar investments.

In other uncontroversial areas, such as networking, Apple's engine loses handily — both today and into the future. The fetch specification underpins browser networking, and WPT scores again highlight the consequences of subsistence-level funding for WebKit:

This continuing embarrassment is not a divergence from historical trends. But for Cupertino to feel any shame, or face any consequences, influential developers like Jeremy will need to look past marketing.

Consequences

These large, persistent gaps matter to the mobile and web ecosystems because Apple is unique in denying access to more capable, less-buggy engines and actively erecting unlawful barriers to choice when forced by legislation to enable it. This is accomplished through eye-watering budgets for legal shenanigans, direct lobbying, and well-heeled astroturf front groups to maintain a capability gap between web and native.⁴

That chasm is instrumental in trapping users and developers in the extractive vice of Cupertino's App Store. A persistent, material gap in capabilities creates a perception of the web being less-than; a budget option for the unserious. Should that perception erode through users choosing more capable, more private, less buggy browsers for a larger share of their computing needs, Apple might lose the leverage that enables it to extract rents.

Cupertino can put up with a lot of things, but it can't abide that. Which is why it spends lavishly to deflect and delay true browser choice, rather than investing those resources in the Safari team.

You Do Not Have To Hand It To Them

Having looked at the data, and having manually dug into dozens of the fixes listed for WebKit in the Networking and HTML sub-areas, I can say with some confidence that Jeremy's praise for Apple's comparative rate of bug fixing is simply off-base.

Cupertino might be talking up how much it cares, and we might all be desperate for green shoots given Apple's iOS hostage-taking, but wishes and blog puffery do not change the reality that Apple is consistently out-engineered and out-invested by a non-profit with 1/40th the web-derived revenue. Against a near peer, Cupertino's continuing under-investment is visible in almost every single area.

What we see in these differences has a name: greed.

Apple is extracting tens of billions of dollars in private profit from browsers while socializing the costs to every digital business forced to work around Safari's buggy engine. Ecosystem-wide deadweight losses are even higher, impacting every user and business forced into the App Store by the incapability of Apple's browser. Not coincidentally, this is where Cupertino can extract its vig. Higher prices for everyone else are not a bug in the mind of the monopolist.

Like test conformance, security and performance are also indicators of quality that comes from consistent investment over time. News recently broke that a Blink for iOS prototype is showing massive performance upside relative to Safari on Apple's own hardware:

That's to say nothing of the heavily requested features we can't use but for Apple's sandbagged engine. Safari engineers have worked behind the scenes to keep important, oft-requested features out of Interop where a lack of progress might make Cupertino's choices more legible. As a result, we (Edge) have had to build a parallel dashboard to track progress on the larger set we'd like to see progress on, but which get cut from that process through secret vetoes.

Here's how that's going in 2026:

Here's the Chromium iOS prototype exercising some of those features versus Safari 26 today:

Blink and Gecko-based iOS browsers would unlock more capable, less buggy websites, better security, and more responsive experiences. Progress would accelerate in a world with competition if only because it would spur Apple to finally fund WebKit at a competitive level. Under-investment is the absentee father of many starving children.

But today, Apple hasn't turned that corner. It's trotting out the same tired playbook:

• Chronically under-fund WebKit despite raking in tens of billions in profit from the web every year.
• Watch Safari fall behind on features, standards conformance, security, and performance.
• Force web developers to cater to that broken target through anti-competitive policies.
• Furiously stage-manage any standards or standards-like process that threatens to create visibility or accountability.
• Market occasional releases as "big" in some narrow dimension.

Except for the ability to lock out other browsers, the script is identical to the one Microsoft tried in the bad old days of IE 7-11.

Which takes us back at square one: how is someone as clever as Jeremy falling for obvious propaganda?

Quality Has A Quality All Its Own

One clue might be the Chromium-originated features he objects to. It's easy to be distracted by things you dislike and think "those people aren't paying attention to <good things>, they're just off on a tangent doing <bad things>". But that sort of feeling isn't data. I am not a fan of all recent Chromium features; in fact I'm the proximate reason the prompt() API hasn't launched more widely in the Chromium ecosystem.⁵

As a Blink API OWNER, my potential concerns about trailblazing efforts take on a specific cast: Chromium and Blink are explicitly organised to make and defend space for leadership, but our ability to lead in new areas is tied to quality. Final feature launch checks are focused on plausible interoperability — will the specs, tests, and implied architecture choices allow other engines to become compatible? — and demonstrations of developer support.

A few years ago I gave a talk for Blink developers outlining how the pieces fit when trying to solve problems for web developers:

TL;DR:, we don't trust ourselves to know all the answers. Instead, the API OWNERS look for quality signifiers, both from an implementation perspective, but also (and more importantly) from the perspective of end developers. When Blink is in the lead, our process is explicit about testing ourselves in an internally adversarial process to answer the question: "does this feature solve an important problem well?"

The key constituency for determining the answer are web developers, not other browser engineers or standards grandees. Working Groups gaining consensus after outbreaks of go fever have been the authors of much suffering, so we explicitly work to ground our analysis in sources of evidence less subject to groupthink.

Blink's process sets a high bar because we know the project is out in front, thanks in no small part to Apple's behobblement of both WebKit and Gecko. It's thanks to Blink's continuous work on conformance and compatibility that we can make path-breaking bets on feature investigations and spend the 3-5x it takes to get it right; particularly when other vendors do not join those (very public) efforts, or weigh in only to object to the colour of the bikeshet at the very last minute.

That's also why we've built mechanisms like Origin Trials to test features without risk of accidental burn-in. Developer feedback is the primary quality signal we evaluate above baseline reviews for security, performance, privacy, and accessibility. It also explains why Blink requires legible explainers, wide review, reasonable specifications, and good tests. We insist that web developers be able to understand and help shape proposals while they're malleable, and when the cement sets, tests and specs should be complete enough to ease the burden on other implementers.

The goal of this system is to pack as much learning as possible into feature development up front, listening to web developers, iterating as we go, and shipping at the speed of developer confidence.⁶

To a large degree, it has worked.

That's not a recipe for perfection, and nobody would claim we are infallible, but it is a recipe for leaving things a bit better than we found them. Listening intently to web developers and iterating in good faith is foundational to our process. But because we are so often in the lead, and so often iterating in public, work hangs in a liminal state longer than things might if we were able to count on other browser vendors engaging constructively. This invites critique, fair and misdirected alike. That's a price we're willing to pay to keep delivering the features developers tell us they need.

So if Jeremy has a problem with specific features, I hope he'll come to us with a critique of their qualities, rather than their optics. Because it's quality that we are always working to build and defend, and it's quality that makes space to solve new problems, rather than endlessly relitigating prior battles.

FOOTNOTES

1. Many of the fixes Apple enumerates are issues that have been identified simultaneously in WebKit and other engines.

   Contributors sometimes fix bugs in multiple engines at the same time; an upside of the modern Open Source browser ecosystem. In other cases the addition of test collateral to WPT encourages projects to quickly address newly discovered gaps.

   In these cases, Apple's forced delay for feature releases hurts the pace of compatibility across the ecosystem. Safari 27 was announced in early June but doesn't launch until September, nearly four months later. Meanwhile in Chromium, the already quick 4-week release cycle has delivered fixes to the Stable channel from nightly builds in two to three months since 2021.

   Not content to rest on that relative advantage, Chromium is in the middle of moving to a two-week release cycle, and most Chromium-based browsers (Chrome, Edge, Opera, etc.) are committed to keeping that faster pace. Instead of a normal-priority fix taking two to three months to stabilise and deploy, the window will now be six weeks at the slowest. Patches that land just before branch cut could see deployment in just over a month, or 4x faster than Apple's feature release cadence for Safari 27.

   The upshot is that many fixes first developed for WebKit will appear for users and developers in Chromium browsers ahead of Safari 27's release. Separate and apart from the large feature gaps that remain endemic to Apple's engine, the slower pace of deployment continues to slow progress across the entire web ecosystem.

   Cupertino can pre-blog all it likes, but the world doesn't improve until the bits on users' disks are upgraded. ⇐

2. The total number of tests enabled varies by less than 1% between engines. Therefore, we can safely compare pass-rates to get a sense of completeness and quality. ⇐

3. There is reason to think that Chromium is missing fewer features than webstatus.dev captures because WebGPU is incorrectly marked as unsupported.

   In reality, WebGPU shipped first in Chromium, has been deployed most widely there (both across OSes and form-factors), and comes with the most expansive set extension features for developers, enabling richer applications more reliably than any other engine. ⇐

4. My own estimates are that Apple clears something like a 95% profit rate on the web-derived revenue it takes from Google via the search deal, most recently revealed in court documents to be worth more than $20BN per year.

   Apple has recently increased its investments in WebKit, but it does not seem likely to have broken $1BN/year, all-up. Even the most Bork-addled thinkers cannot deny that margins this large, this sustained, on a product with defects so glaring must be the result of anti-competitive abuses of market power. Earning more than 40x Mozilla's income on a pure substitute, while delivering a substantially inferior product, hinges on excluding more competitive players from entering iOS.

   A market with real competition would force Apple to invest substantially more, would quickly improve quality across the ecosystem, and would deliver major gains to developers and end-users. Which is precisely why Apple won't allow it. ⇐

5. The case of the prompt() API is a microcosm of Blink's values in a telling moment: a call we got wrong. As far as I can tell, Google enabled it for Chrome, proximately, in order to have something to talk about at I/O. This is a failure mode we try to guard against. Other Blink-ecosystem browsers pushed back, noting the lack of public test collateral and challenges in achieving interoperability. Unfortunately, and to my shame, I spotted that the Intent had garnered the necessary three votes to ship weeks after the branch cut.

   What happened next matters a great deal.

   Instead of doubling down on their position, Googlers took the concerns in the thread seriously, patiently answered questions, and are now working with the community to generate a comprehensive test suite. That should have happened prior to removing the OT requirement, but there is now a path to plausible interoperability based on objective quality metrics. No other Chromium-based browser is likely to ship until they're satisfied with the results.

   This is an uncomfortable and unusual situation. The API OWNERS have been clear with the team that they are expected to be responsive to ongoing developer feedback post-launch, and if radical changes are necessary post-launch, the Blink process provides that flexibility on an exceptional basis. Teams are guided not to make breaking changes, in part, because it harms developers. Because we care deeply about developers and not breaking the web, that harms the reputation of the team among the API OWNERS. Groups with a track record of causing pain for the ecosystem face heightened scrutiny when proposing subsequent features, and it's safe to say that the group that pushed prompt() through without bringing the rest of the Chromium community along is now in that unenviable position.

   Because Blink and Chromium feature useful, anonymised telemetry, we can keep hawkish tabs on growth of use of the API, currently several orders of magnitude below the rule-of-thumb use threshold (0.03% of pageloads) above which changes and deprecations become much harder to pull off. We're still in a moment when all's to play for. ⇐

6. It's telling that Apple has not replicated these learning and iteration processes, preferring instead to move design conversations into smoke-filled rooms where it can leverage an explosion of veto players to obscure a fifth-column agenda.

   Jeremy is sceptical about the motives of Googlers asking which features to prioritise, and scepticism is always healthy — but only when applied evenly.

   To get a sense of the degree of good faith inquiry, we have to judge by track records; which engines give developers a structural voice in feature evolution? Which processes force work into the venues where developers can engage without committing to a Working Group meeting schedule (e.g., through incubation venues)? Which products provide transparent ways to engage, test early prototypes, and force developers to iterate in public?

   By contrast, which teams are working tirelessly to tear down and ignore easy-on-ramp venues? Fail to provide open processes for feature approval or insight into roadmaps? And which teams most often present fait accomplis, rather than opportunities to shape the future? ⇐

Ming-Chi Kuo:
Kuo: Apple suppliers plan to ship <1M iPhone fold units in Q3 2026, which may push the start of device pre-orders and sales to Q4, with weeks of delivery delays  —  My latest industry survey indicates that assembly shipments for the foldable iPhone in 2H26 will be roughly 7-8 million units …

Most Americans don't trust AI. It's proven that it doesn't know what safe toppings for pizza are. People don't even want to listen to AI music. But none of that matters for some of America's wealthy, who are turning to AI to teach their kids instead of traditional schools. Companies like Forge Prep and Alpha […]

Grace Kay / The Information:
Tesla rolls out its Robotaxi service without a safety monitor in Miami, its fifth city, as it aims to expand to a dozen US states by the end of 2026  —  Tesla said it rolled out its Robotaxi service in Miami on Friday, according to a post from its social media account on X.

Startups built around AI hire fewer entry-level workers than their peers, according to a working paper from Harvard Business School and INSEAD, first reported by Business Insider. The firms are leaner, flatter, and heavily weighted towards senior technical talent. Researchers Rembrand Koning and Hyunjin Kim examined Y Combinator startups from 2020 to 2024 alongside a broader set of […]

This story continues at The Next Web