Browser Engines 2026 — Chromium, Gecko, WebKit, Servo, LadyBird: Who Is Actually Rendering the Web

Prologue — Three engines paint the web

Behind the screen you are reading right now sits a rendering engine: hundreds of thousands of lines of C++ that parse HTML into a DOM, match CSS to produce a style tree, fold both into box and layer and paint trees, and finally hand textures to the GPU. We use this stack every day. We almost never look at it.

As of May 2026, across desktop, mobile, and tablet combined, three engines account for essentially all of the web's rendering:

• Blink (Chromium family) — about 81%. Chrome, Edge, Brave, Arc, Opera, Vivaldi, Samsung Internet, and almost every desktop app shipped on Electron.
• WebKit (Apple) — about 14%. Safari, and — at least outside the EU — every browser on iOS, because the App Store mandates WebKit (Chrome iOS, Firefox iOS, Edge iOS are all WebKit wrappers).
• Gecko (Mozilla) — about 3%. Firefox and its derivatives. The last major engine that is genuinely neither Chromium nor Apple.

That is the entire picture. The three of them together carry 99%. The remaining 1% is split between Pale Moon's Goanna, Ekioh's GPU-accelerated commercial engine Flow, and — most interestingly — two ground-up rewrites: Servo (Mozilla's Rust engine) and LadyBird (Andreas Kling's independent C++ engine).

This post maps those three engines and the two indies trying to crack the picture in 2026. And it asks:

Can we really survive on one engine owning more than 80% of the web? Are three engines enough diversity? And — can Servo or LadyBird actually reach production?

1. How we ended up with three engines — thirty years compressed

The history of browser engines is short and dense. Compressed:

1.1 1993–2003: Mosaic, Netscape, IE, KHTML

• Mosaic (1993) — the first graphical browser. NCSA, then forked off into Netscape.
• Netscape Navigator (1994) — built by Mosaic veterans, with a proprietary engine. Open-sourced in 1998 — the seed of the Mozilla project, and from there, Gecko.
• Internet Explorer (1995–) — Microsoft licensed Mosaic, built the Trident engine. By the late 1990s IE held more than 90% of the market and effectively defined the web.
• KHTML (1998) — KDE's Konqueror browser engine. A clean, small C++ codebase. Apple forked it in 2003 to create WebKit.

1.2 2003–2013: WebKit appears, Chrome changes everything

• WebKit (2003) — Apple forks KHTML, ships with Safari 1.0.
• Chrome (2008) — Google forks WebKit, pairs it with the V8 JavaScript engine, and introduces the multi-process architecture that defines modern browsers.
• Blink (2013) — Google diverges from WebKit into its own engine. Opera abandons its Presto engine and adopts Blink the same year.

1.3 2013–2020: The acceleration of monoculture

• Microsoft Edge (2015) — IE retired, replaced by EdgeHTML. The new engine never gains share.
• Edge — Chromium (2020) — Microsoft drops EdgeHTML and rebases Edge on Chromium. At this moment, the desktop engine count collapses to three.
• Servo (2012–2020) — Mozilla's parallel Rust engine. Dormant after the 2020 Mozilla layoffs.

1.4 2020–2026: Revival and cracks

• Servo (2023) — Moved to Linux Foundation Europe (LFE), development restarts. By 2026 Servo demos an embedded use case and a minimal browser shell.
• LadyBird (2022–) — Andreas Kling (ex-Apple WebKit, founder of SerenityOS) spins out LadyBird as an independent project. The non-profit LadyBird Browser Initiative is incorporated in 2024. Funded by GitHub/Shopify founders (notably Chris Wanstrath and Tobi Lutke). Roughly ten full-time engineers. First Alpha targeting July 2026 for Linux and macOS. Windows and Android come later.
• EU DMA lifts iOS WebKit mandate (2024) — In the EU only, Apple must allow non-WebKit engines on iOS. Chrome iOS ships a Blink variant in pilot. Real usage moves slowly, but one of the pillars has wobbled.
• DOJ vs Google ruling (August 2024) — A US federal court rules Google illegally maintains a monopoly in search. The 2025 remedies phase sees the DOJ recommend divesting Chrome. As of mid-2026, the appeal is still in progress. If forced, the browser landscape shifts again.

The point of this chapter: the three-engine state is not equilibrium. It is the residue of accumulated mergers. Four to five engines existed in the late 1990s. The mid-2010s compressed them into three. The mid-2020s have begun to diverge again — slowly, but visibly.

2. Engine-by-engine anatomy

2.1 Chromium / Blink — the de facto standard

Owner: Google (BSD-style open source, but a single company effectively drives direction)

JS engine: V8

Render pipeline: Blink — cc (compositor) — Viz (GPU process) — Skia / Dawn

Browsers:

• Chrome (Google)
• Edge (Microsoft, switched in 2020)
• Brave (privacy focus)
• Arc / Arc Search (The Browser Company)
• Opera (switched 2013)
• Vivaldi
• Samsung Internet
• Yandex Browser
• Naver Whale
• Dozens of minor forks
• Electron-based desktop apps (VS Code, Slack, Discord, Notion, Figma desktop, etc.)
• Some Tauri configurations (Tauri defaults to OS WebView, but a Bundled Chromium option exists)

Strengths:

• Fastest standards adoption. Container Queries, View Transitions, Anchor Positioning all shipped first.
• Industry-standard developer tools.
• Broadest WebGPU, WebRTC, and media codec support.

Weaknesses:

• One company effectively defines de facto standards. "Blink supports it" is treated as equivalent to "it is a standard."
• High memory footprint — hundreds of megabytes per tab.
• Manifest V3 has degraded extension capabilities, especially for content blocking — uncomfortable given Google's ad business.

Governance: Open in form, but commits are almost entirely from Google. Microsoft contributes around Windows and accessibility since adopting Edge. Igalia, a Spanish consultancy, is the most significant external contributor — Container Queries, MathML, and other features.

2.2 WebKit — Apple's walled garden

Owner: Apple (mixed LGPL / BSD)

JS engine: JavaScriptCore (JSC)

Render pipeline: WebCore — WebKit2 (multi-process) — Metal / CoreAnimation

Browsers / platforms:

• Safari (macOS, iOS, iPadOS, visionOS)
• Effectively all iOS browsers — App Store policy enforces WebKit (Chrome iOS, Firefox iOS, Edge iOS, Brave iOS are all WebKit wrappers)
• Since 2024 EU DMA, EU-only iOS allows non-WebKit, gradual adoption
• macOS SwiftUI WebView and AppKit WKWebView
• PlayStation 5 system browser
• Amazon Kindle, BlackBerry, Tizen, and other embedded platforms

Strengths:

• Excellent GPU and media integration on macOS / iOS (Metal backend).
• Energy efficiency — leader in battery-aware design for laptops and phones.
• Privacy — Intelligent Tracking Prevention (ITP) pioneered modern anti-tracking.

Weaknesses:

• Slow standards adoption for many features. WebGPU, WebRTC, OffscreenCanvas, Service Worker all arrived one to two years after Blink and Gecko.
• iOS WebKit enforcement — outside the EU — denies users genuine engine choice.
• Developer tools are weaker than Blink and Gecko.

Governance: Almost all commits from Apple. Igalia maintains WPE WebKit, the embedded variant. Sony contributes around the PS5 browser.

2.3 Gecko — the last non-Chromium flag

Owner: Mozilla Foundation / Mozilla Corporation (MPL 2.0)

JS engine: SpiderMonkey

Render pipeline: Gecko — WebRender (Rust-based GPU compositor) — Direct3D / Metal / OpenGL

Browsers:

• Firefox (desktop, Android)
• Firefox ESR
• LibreWolf (privacy-hardened fork)
• Waterfox (legacy extension compatibility)
• Tor Browser (built on Firefox ESR)

Strengths:

• The strongest default privacy posture. Tracking protection and fingerprint resistance ship as defaults.
• WebRender — a Rust-rewritten GPU compositor, very efficient at the composition stage.
• A genuine counterweight in standards committees, however small.

Weaknesses:

• Resources are thin. Mozilla went through major layoffs in 2020 and again in 2024. As of 2026, the full-time Gecko engine engineer count is somewhere in the high single digits to low double digits.
• Standards adoption often lags Blink by six to twelve months. WebGPU only stabilized in late 2025.
• Tiny mobile share — low single digits on Android, effectively zero on iOS where it is a WebKit wrapper.

Governance: Mozilla-led. External contributions exist but are small in share. From 2024 onward, the diversification of Mozilla into advertising, AI, and other businesses has fueled the "Mozilla mission drift" debate — is Gecko investment actually decreasing?

2.4 Servo — the Rust rewrite

Owner: Linux Foundation Europe (since 2023)

JS engine: SpiderMonkey (borrowed from Gecko)

Render pipeline: Pure Rust. Parallel layout, parallel paint — multi-core utilization is the design center.

History:

• Started in 2012 at Mozilla Research. Parts of Servo (the style system, WebRender) were upstreamed into Gecko.
• Went dormant in the 2020 Mozilla layoffs.
• LFE took over operations in 2023. Igalia, Huawei, and volunteers contribute. Active development has resumed.

Status in 2026:

• Renders simple pages, CSS, and JS on Linux and macOS.
• A demo browser shell is shippable.
• Focus on embedded use cases — automotive infotainment, kiosks, appliance UIs.
• Under review as an experimental backend for Tauri.

Distance to production: For a general-purpose desktop browser, the gap is still enormous. Site compatibility is the hard part.

2.5 LadyBird — the most exciting indie

Owner: LadyBird Browser Initiative (501(c)(3) non-profit, founded 2024)

JS engine: LibJS (custom)

Language: C++23 (originated as the SerenityOS LibWeb component)

History:

• Began in 2019 as a SerenityOS subcomponent built by Andreas Kling.
• Split into an independent project in 2022.
• The LadyBird Browser Initiative non-profit was created in 2024. Initial funding from GitHub and Shopify founders (Chris Wanstrath, Tobi Lutke) plus follow-on donors. Multi-million-dollar runway.
• Around ten full-time engineers.

Status in 2026:

• First Alpha targeting July 2026 — Linux and macOS.
• Web Platform Tests pass rate has risen quickly (roughly 80% in mid-2024 — 90% or higher in selected areas by early 2026).
• HTTPS, HTML5, most CSS, JavaScript at the ES2022 level, plus some Web APIs. Multi-process architecture with per-tab process isolation.
• WebGPU, WebRTC, and media codecs are not yet usable or are very early.

Philosophy:

• Independence first — no ad revenue, VC, or search deals. Donations and grants only.
• Built from scratch — not a fork.
• Standards-pure — no user tracking. Site compatibility is a stated priority.

Distance to production: The Alpha proves technical feasibility. Daily use for general users is, optimistically, 2028 or later. But for the first time in roughly 30 years there is a genuinely new major browser engine in active development. That fact alone matters.

2.6 Flow — commercial indie

Owner: Ekioh (Cambridge, UK)

Language: C++, custom GPU-acceleration library

Use case: Embedded — kiosks, set-top boxes, automotive infotainment. Not a consumer browser.

Distinctives:

• Everything composited on GPU — minimal CPU overhead.
• Multi-threaded layout.
• Standards adoption is selective based on customer requirements.

Flow matters because it is a second indie engine that already renders parts of major sites. Together with LadyBird, it is living proof that independent engines remain feasible.

2.7 Goanna — the preservationist flag

Owner: Moonchild Productions (Pale Moon)

Origin: Forked from Gecko in 2015, to preserve XUL extensions and other capabilities Firefox dropped.

Use case: Pale Moon, Basilisk.

Reality: Share below 0.1%. Standards adoption is slow. Modern sites often break. But it preserves a small community focused on user control.

3. Feature coverage matrix

A snapshot of feature support by engine. O = stable, ~ = partial or behind a flag, X = not supported, - = not applicable.

Approximate Web Platform Tests pass rates in early 2026:

LadyBird climbing this quickly is remarkable for a team this small over six years.

4. Where sites actually break — real compatibility today

Tables stay clean. Reality does not. Here is what tends to break, by engine, as of May 2026.

4.1 Safari / WebKit patterns

• <input type="date"> interaction differences — iOS Safari forces the native picker, desktop Safari uses a non-standard UI.
• PWA constraints — Add to Home Screen works, but Service Worker storage and push notification capabilities lag, even after 2024 EU policy changes.
• IndexedDB transaction timing — Safari's IDB hits subtle lock conflicts more often than other engines.
• WebRTC ICE candidate negotiation occasionally fails on asymmetric NAT, especially on mobile.
• Media codecs — VP9 and AV1 work on desktop, are limited on mobile. H.264 and HEVC get priority.
• No File System Access API — desktop-class file workflows are not possible.

4.2 Firefox / Gecko patterns

• Aggressive tracking protection — by design — breaks sites that depend on trackers. Blank screens are not unusual.
• WebGPU and OffscreenCanvas are stable now but arrived six to twelve months after Blink. Sites from that window sometimes break.
• Tiny mobile share means sites barely test on Firefox Android. Chromium-only CSS features just go unhandled.
• DRM content uses Widevine as a separately loaded module — sometimes disabled in hardened configurations.

4.3 Chromium can break too

This gets forgotten. "Chrome" does not mean "guaranteed."

• Manifest V3 has degraded extensions, especially advanced content blocking and automation tooling.
• Origin Trials — code that assumes a trial-only feature will silently break once the trial expires.
• Subtle behavior differences between ChromeOS, Android WebView, and Electron.
• Edge, Brave, Opera, and other derivatives bundle ad and tracker blocking that can break sites in ways the upstream Chrome team did not.

4.4 A realistic cross-engine test matrix

For small teams. The minimum sensible matrix:

Servo and LadyBird, as of 2026, are not part of mainstream site testing. At this stage the engines should accommodate sites, not the other way around.

5. Politics — DOJ, DMA, and Mozilla's drift

5.1 DOJ vs Google — will Chrome get split?

In August 2024 a US federal court ruled that Google illegally maintains a monopoly in search under Sherman Act Section 2. In the 2025 remedies phase the DOJ recommended:

1. Divest Chrome — Google sells off the Chrome browser business.
2. Ban search defaults deals — prohibit the roughly USD 20 billion-per-year Apple default search deal.
3. Data sharing — open parts of the search index and ranking signals to competitors under conditions.

Google appealed. As of May 2026 the case sits in the appeals court. A final outcome is unlikely before 2027.

If a Chrome divestiture is forced:

• Chromium open-source governance becomes uncertain. Who pays the operating costs Google was funding?
• V8 and Blink development would slow in the short term.
• Microsoft Edge is already Chromium-based and is less affected. Effective influence over the platform partly shifts to Microsoft.
• For diversity, it is paradoxically a positive signal. A single actor's control loosens.

5.2 EU DMA — the end of iOS WebKit enforcement?

The EU Digital Markets Act (DMA) took effect in March 2024. In the EU only, Apple must permit non-WebKit engines on iOS.

As of 2026:

• Chrome iOS with a Blink-based variant is rolling out to EU users — not as the main app, but as a separate SKU users must actively opt into.
• Firefox iOS with Gecko piloted in 2025 and went into wider EU rollout in 2026.
• Apple has interpreted the DMA narrowly — JIT restrictions, a separate security model, and additional warnings ensure the first-run experience of non-WebKit engines is intentionally rough, critics say.
• Outside the EU (United States, Asia, Japan, etc.), nothing changes. Similar US legislation has stalled.

For engine diversity inside the EU, this is a small win. But meaningful share shifts have not happened yet.

5.3 The Mozilla mission drift debate

Mozilla is effectively the only major institution preserving a non-Google, non-Apple engine. But the 2020s pattern has fueled growing criticism:

• 2020 layoffs — large cuts, including most of the Servo team.
• 2022 onward — emphasis on AI, advertising, and privacy products. Mozilla.ai founded. The advertising company Anonym acquired in 2024.
• 2024 additional layoffs — around 60 people, including some standards-committee participation.
• 2026 — full-time Gecko engineers are estimated at high single digits to low double digits, down from hundreds in the mid-2010s.

The case for: "Revenue diversification is essential. We cannot keep depending on the Google search deal." More than 80% of Mozilla's revenue comes from that deal. If the DOJ remedies forbid it, diversification is survival.

The case against: "Investment in the engine is going negative, but Mozilla is funding advertising and AI? Is it appropriate for an organization with a public-interest mission to acquire an ad company?"

There is no clean right answer. Resource allocation is hard. What is clear: Gecko is too dependent on one organization.

6. Why diversity matters — the monoculture risk

"Chromium does well enough" is a common counterargument. Standards adoption is fast, the dev tools are great, and it is open source. Do we really need other engines?

We do. A few reasons.

6.1 If one company defines a standard, it is not a standard

W3C and WHATWG standards are effectively vetoed by Blink. A feature Blink does not implement is, practically, not a standard. A feature Blink starts puts pressure on other engines to follow.

This is the IE era repeating. In the late 1990s, with IE at 90% share, Microsoft pushed ActiveX, VBScript, and HTC as quasi-standards. The web got locked to IE. Other browsers broke.

Blink is not doing this intentionally. It is structurally in that position. Good or bad, that is dangerous.

6.2 Ad and tracking model monoculture

Manifest V3 has legitimate justifications. It also reduced ad-blocker capabilities. That conflicts with the fact that Google's core revenue is advertising.

Gecko sends a different signal even at small share. uBlock Origin runs on Firefox with stronger APIs than under Manifest V3. That is the value of diversity in trust.

6.3 Security single point of failure

A CVE in Blink affects Chrome, Edge, Brave, Arc, and the entire Electron app ecosystem at once. When a V8 zero-day was found in 2022, essentially every desktop user was exposed until patches rolled out.

Engine diversity, in security, is exactly like species diversity in an ecosystem. One pathogen should not knock everyone over at once.

6.4 Competition drives innovation

When WebKit was slow on Service Worker, Blink and Gecko pushed it forward and eventually Apple followed. Gecko's WebRender pushed composition efficiency to a new level and Blink borrowed parts. Without competition, everybody stalls.

7. What it would take to get Servo and LadyBird to production

So can a genuinely new engine become major? Let us be honest.

7.1 Servo

What is left:

• Site compatibility. Reaching 99% of real-world sites means handling endless edge cases. WPT pass rate from 78% to 95% — the final 17% is the hardest.
• Full DOM, CSS, and JS API surface. WebRTC, WebAuthn, Service Worker not yet implemented.
• Developer tools.
• An extension system — or a deliberate decision not to have one.
• Funding. LFE provides governance, but full-time engineer count is single digits.

Opportunities:

• Embedded-first strategy. Automotive, kiosks, and appliances tolerate looser site-compatibility requirements.
• Integration with the rest of the Rust ecosystem — Tauri and other frameworks.

Realistic timeline: A general-purpose desktop browser is 5+ years out. Embedded adoption: 2027 to 2028.

7.2 LadyBird

What is left:

• Ship the Alpha (target July 2026). Then crank site compatibility, performance, and stability quickly.
• WebGPU, WebRTC, media codecs — enormous bodies of work for a small indie team. Strategies include reusing Skia, FFmpeg, and similar libraries.
• Port to Windows and Android. iOS is hard on policy grounds alone.
• Funding longevity. The 2024 seed funding buys years. After that, what?

Opportunities:

• True independence. No ad pressure, no search deals, no VC pressure. Decisions are based on user experience.
• The narrative power of the first real new engine in 30 years.
• A deliberately clean codebase that lowers the bar for new contributors.

Realistic timeline: Alpha in July 2026. Beta (usable with known limitations) in 2027 to 2028. Daily use for general users: 2028 to 2030.

7.3 Even if both fail

Even if neither reaches major share, the work matters. Reasons:

• New voices in standards committees — one indie engine present makes deliberations more careful.
• Pressure on Chromium — a social signal that Chrome is not the only option in the monoculture.
• A school for the next generation — Servo's Rust and LadyBird's C++23 train new engine engineers.
• Embedded and special-purpose alternatives — automotive, kiosks, and embedded prefer indie engines for license and control reasons.

8. What practitioners should actually do

If you are reading this as a web developer, what changes?

8.1 Multi-engine testing in CI

GitHub Actions and equivalents run Playwright across Chromium, WebKit, and Firefox automatically. It is free. There is no excuse.

# .github/workflows/test.yml (example, inside code block only)
name: cross-browser-tests
on: [push, pull_request]
jobs:
  test:
    strategy:
      matrix:
        browser: [chromium, webkit, firefox]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npx playwright install ${{ matrix.browser }} --with-deps
      - run: npx playwright test --project=${{ matrix.browser }}

8.2 Use features at Baseline, not at the bleeding edge

web.dev/baseline or caniuse will tell you whether a feature is stable across all three engines. Anything in Baseline 2024 or later is safe to use. Anything below it needs a polyfill or a progressive enhancement path.

8.3 Be careful with Origin Trials

Chromium's Origin Trials encourage code to depend on new features. When the trial expires, every site that depended on it breaks suddenly. Avoid if possible, or always polyfill.

8.4 Do not ignore engines with small share

Firefox at 3% is still real users. Small effort gives a meaningful return.

8.5 Standards first

When you use vendor prefixes (-webkit-, -moz-), always include the standard form alongside. Avoid patterns that lock the site to a single engine.

Epilogue — A 30-year inflection

If you compress the history of browser engines, true inflection points are rare. Netscape in 1994, WebKit in 2003, Chrome in 2008, Blink in 2013 — and 2026 may be the next.

LadyBird's Alpha, Servo's revival, the DOJ's recommendation to divest Chrome, the EU DMA prying open iOS, Mozilla's mission drift — none of these create an immediate result on their own. But stacked together, the web of the 2030s could look meaningfully different from the web of the 2020s.

Checklist

• Does our site run without regressions on Chrome, Safari, and Firefox?
• Do we run cross-engine CI tests with Playwright or an equivalent tool?
• Are sub-Baseline features wrapped in polyfills or progressive enhancement?
• When we use vendor prefixes, do we always include the standard form?
• Are we free of hard dependencies on Origin Trials?
• Does our site's core functionality work without JavaScript?

Anti-patterns

• "Test only on Chrome" — other engines are quietly breaking.
• "User-Agent sniffing" — almost always breaks in the future.
• "Assume Service Worker support everywhere" — Safari and iOS quirks.
• "Firefox share is small, so ignore" — Firefox is the compatibility canary.
• "Manifest V3 extensions equal Manifest V2 extensions" — they do not.

Next post

The next post will dig into embedding these engines into desktop apps — Electron vs Tauri vs WebView. Bundle the entire Chromium (Electron)? Borrow the OS WebView (Tauri)? Drive WebView2 or WKWebView yourself? With the security, memory, and bundle-size tradeoffs of each.

References

• State of the browser engines (web.dev) — Baseline-driven feature tracking.
• Web Platform Tests — cross-engine standards conformance.
• Chromium — official project.
• WebKit — Apple's engine.
• Mozilla Gecko docs — Gecko documentation.
• Servo — Linux Foundation Europe project.
• LadyBird Browser — indie engine.
• Ekioh Flow — commercial indie engine.
• Pale Moon (Goanna) — preservationist Gecko fork.
• DOJ vs Google (2024 ruling summary) — US Department of Justice.
• EU DMA — Apple iOS browser engine — EU Digital Markets Act.
• caniuse.com — per-feature engine support.
• Web Almanac — annual web ecosystem statistics.
• Igalia — external engine contributor.
• Andreas Kling's blog — LadyBird developer blog.