keepcalculator

06 Numbers and Powers

Why Google Forked WebKit: Blink Lessons

Card No. 06·77439 · Updated · Standard formula, shown below

Google forked WebKit to create Blink because it wanted to take control of its own rendering engine roadmap, rather than negotiating every architectural change with the other WebKit contributors, especially Apple. The fork, announced in April 2013, was driven by a fundamental disagreement over the direction of the engine’s architecture, and it allowed Google to build a faster, more sandboxed, and more independently evolvable browser engine. This article explains the technical, organizational, and strategic reasons behind the fork, what actually changed, and what other browser projects can learn from it.

Background: What WebKit and Blink Are

WebKit is a browser rendering engine that originated from Apple’s fork of KHTML (the engine used by Konqueror) in 2001. It powers Safari and, for years, Chrome and many other browsers. Blink is a fork of WebKit’s WebCore component, created by Google in 2013, and it now powers Chrome, Edge, Opera, Brave, and many other Chromium-based browsers.

The key difference is not cosmetic: a rendering engine is the software that takes HTML, CSS, and JavaScript and turns them into the pixels you see on screen. It includes the DOM (Document Object Model) implementation, the CSS layout engine, and the JavaScript engine (V8 in Chrome’s case, JavaScriptCore in Safari’s). When Google forked WebKit, it effectively took a snapshot of WebCore and started developing it independently under the name Blink.

Why Google Forked WebKit: The Core Reasons

Google’s stated reasons, from the official 2013 blog post and subsequent developer talks, can be summarized as:

  • Architectural divergence: Google wanted to make deep changes to the rendering engine’s architecture, such as moving more of the rendering pipeline to a separate process (the “sandbox” for renderer processes) and redesigning how the engine handles multi-threading. Apple and other WebKit contributors were more conservative, fearing that such changes would destabilize Safari and the WebKit2 API.
  • Decision-making speed: WebKit had a multi-company governance structure where significant changes required consensus. Google felt that this slowed down innovation. With Blink, Google could set the direction unilaterally, while still allowing external contributions under its own review process.
  • Reducing complexity: WebKit supported multiple ports (GTK, Qt, EFL, etc.) and multiple JavaScript engines (JSC, V8). Google’s version of WebKit already had its own build system and a modified JavaScriptCore integration. Forking allowed Google to strip out the ports it didn’t use and focus on its own platform.
  • Sandboxing and security: Google’s multi-process architecture (each tab as a separate process) required a rendering engine that could be safely isolated. Blink was designed from the start to support this model, with a clear separation between the “browser” process and the “renderer” processes.

In short, the fork was a classic “if you want it done right, do it yourself” move. Google had the resources and the user base (Chrome was already the most popular browser) to make the fork viable, and it did not want to be held back by a committee.

How the Fork Worked: Technical Details

Technically, Blink began as a copy of WebKit’s WebCore, with the build system and platform-specific code removed. The JavaScript engine was already V8 in Chrome’s case, so that remained. The main changes in the early days were:

  • Removal of multi-process support from WebKit: WebKit had a “WebKit2” API that supported multi-process, but it was not the default. Blink made the multi-process model mandatory and redesigned the IPC (inter-process communication) layer.
  • New layout engine: Blink initially used the same WebCore layout engine, but over time it was rewritten. The most notable change was the introduction of the “Blink” layout engine (later renamed to “LayoutNG”) in 2016, which was a ground-up rewrite of the layout code to be more predictable and faster.
  • Removal of legacy code: WebKit had support for old Apple-specific technologies like the Objective-C bindings and the “WebKit” C API. Blink dropped these, reducing the codebase size significantly.
  • Adoption of a “feature-led” development model: Blink introduced a formal process for adding and removing web platform features, with a public “intent to implement” and “intent to ship” process that is still used today.

The fork was not a clean break; Google continued to share code with WebKit for a while, but the two engines diverged quickly. Today, they share very little code beyond the CSS parsing and some low-level utilities.

Immediate Consequences: What Changed in the Browser Landscape

Within a year of the fork, the effects were clear:

  • Chrome became faster: Blink allowed Google to optimize for its own priorities: speed, stability, and security. Chrome’s rendering engine became more efficient, and the multi-process model became more robust.
  • WebKit lost market share (in terms of engine usage): Since Chrome was the dominant browser, Blink quickly became the most widely used rendering engine. Safari and other WebKit-based browsers became a minority, which meant that web developers had to test against two engines instead of one (Blink and WebKit, plus Gecko for Firefox).
  • Other browsers followed: Opera, which had been using its own Presto engine, switched to Chromium (and thus Blink) in 2013. Later, Microsoft Edge switched from its own EdgeHTML to Chromium in 2020, making Blink the de facto standard for all major browsers except Safari and Firefox.

Common Misconceptions: “Blink is Just WebKit”

A common misconception is that Blink is simply a renamed WebKit and that the fork was just a marketing move. That is not true. While Blink started as a copy, it has since diverged dramatically. For example:

  • Layout engine: WebKit uses a layout engine called “WebKit Layout” (still based on the original WebCore), while Blink uses LayoutNG, which is a completely new layout engine designed for modern CSS (flexbox, grid, etc.).
  • JavaScript engine: WebKit uses JavaScriptCore (JSC), while Blink uses V8. They are completely different implementations with different performance characteristics.
  • Process model: WebKit’s multi-process support (WebKit2) is optional and can be used with different process models, while Blink’s process model is fixed and deeply integrated with Chromium’s browser process.
  • Feature support: Blink and WebKit have different feature sets. For example, Blink was the first to ship CSS Grid (though WebKit followed), and WebKit has some features that Blink does not (like certain Safari-specific CSS properties).

So while they share a common ancestor, they are now distinct engines with different codebases, different bugs, and different priorities.

Lessons Learned: What the Fork Taught the Web Platform

The WebKit/Blink fork offers several lessons for the web platform and for open-source projects in general:

  • Forking is not always bad: The fork led to a more diverse ecosystem (two major engines instead of one) and allowed Google to innovate faster. It also pushed WebKit to improve its own performance and features to remain competitive.
  • Governance matters: The fork was a result of governance failure – the WebKit project could not accommodate the needs of its largest contributor. This highlights the importance of having a clear, responsive governance model for large open-source projects.
  • Standards are more important than engines: Even though the engines diverged, the web platform itself remained largely interoperable because both engines implemented the same web standards (HTML, CSS, JS). The fork did not break the web, because standards bodies (like WHATWG and W3C) continued to define the behavior that both engines implement.
  • User choice is limited: The flip side is that the fork reduced engine diversity in the long run, as most browsers now use Blink. This has led to concerns about a “monoculture” where a single engine has too much influence over web standards. Firefox (Gecko) and Safari (WebKit) remain the only independent engines, and their market share is small.

Comparisons: Blink vs. WebKit vs. Gecko

To understand the impact of the fork, it helps to compare the three major engines today:

  • Blink (Chromium): Used by Chrome, Edge, Opera, Brave, and many others. It is the most widely used engine, has the fastest release cycle (every 4 weeks), and is highly optimized for modern web apps. It is also the most complex, with a large codebase and a heavy reliance on multi-process architecture.
  • WebKit (Safari): Used by Safari and all iOS browsers (since Apple requires WebKit on iOS). It is known for its energy efficiency and tight integration with Apple’s ecosystem. It is generally considered to be more conservative in adopting new features, but it has strong support for many CSS and JavaScript features.
  • Gecko (Firefox): Used by Firefox and some niche browsers. It is the only major engine that is not based on WebKit or Chromium. It is known for its strong privacy features and its commitment to open standards, but it has a smaller market share.

The fork effectively created a duopoly (Blink and WebKit) with a smaller third player (Gecko). This has implications for web development: developers must test against at least two engines (Blink and WebKit) and ideally three (Gecko) to ensure compatibility.

Frequently Asked Questions

Is Blink the same as Chromium?

No. Chromium is the open-source browser project that includes the Blink rendering engine, the V8 JavaScript engine, and the browser UI. Blink is just the rendering engine component. Other browsers like Edge and Opera use Chromium, which includes Blink, but they add their own UI and features on top.

Did Apple sue Google over the fork?

No. WebKit is open-source (under the LGPL and BSD-style licenses), so Google was legally entitled to fork it. Apple did not sue, and the two projects have maintained a cordial relationship, with some code sharing (e.g., in the CSS parser) for a while after the fork.

Why didn’t Firefox switch to Blink?

Firefox uses its own Gecko engine, which is developed by Mozilla. Switching to Blink would have made Firefox a “skin” over Chromium, which would have reduced its independence and its ability to innovate on the web platform. Mozilla has chosen to keep its own engine to maintain diversity and to pursue its own priorities (privacy, for example).

Does the fork affect web developers?

Yes, but mostly in terms of testing. Developers need to test their sites in both Blink-based browsers (Chrome, Edge) and WebKit-based browsers (Safari) to ensure compatibility. The two engines have different bugs and different levels of support for certain features, so cross-browser testing is essential.

Is Blink more secure than WebKit?

There is no simple answer. Both engines have had security vulnerabilities, and both have improved over time. Blink’s multi-process architecture provides better isolation between tabs, which can limit the impact of a vulnerability. WebKit has also adopted multi-process on iOS and macOS, but the implementation differs. Security depends more on the overall browser design and the speed of patching than on the engine alone.

Will there be another fork of Blink?

It is possible but unlikely in the near term. Forking a rendering engine is a massive undertaking, and there is little incentive for other companies to do so because they can use Chromium for free. The only reason to fork would be to gain independence from Google’s control, but that would require a huge investment and a clear strategic reason.

Related

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →