What is a browser engine, and how do Blink, Gecko, and WebKit differ? See which engine your browser really uses — and why the user-agent can lie about it.
A browser engine is the software inside your browser that turns a page's HTML, CSS, and JavaScript into the pixels you see and the behavior you experience. Today three engines power almost the entire web: Blink (Chrome, Edge, and most other browsers), Gecko (Firefox), and WebKit (Safari and every browser on iOS). Which one you're using shapes how sites render, what features work, and how identifiable you are — and the user-agent string that claims to tell you can be faked. This guide explains each engine, how they relate, and how to check your real one.
What is a browser engine?
A browser engine — also called a rendering or layout engine — is the component that reads a web page's code and lays it out on screen. When you open a page, the engine parses the HTML into a document tree, applies the CSS to style and position everything, and paints the result. It also runs alongside a separate JavaScript engine that executes the page's scripts.
These two pieces are often confused. In Chrome, for example, Blink is the rendering engine while V8 is the JavaScript engine, and Chromium is the open-source project that bundles them into a browser. Firefox pairs Gecko (rendering) with SpiderMonkey (JavaScript); Safari pairs WebKit with JavaScriptCore. When people say "browser engine," they usually mean the rendering engine, which is what determines how a page looks.
Blink (Chrome, Edge, and most browsers)
Blink is Google's rendering engine and the most widely used by a large margin. It powers Chrome, Microsoft Edge, Opera, Brave, Vivaldi, and the many other Chromium-based browsers — together a dominant majority of desktop browsing, on the order of three-quarters of the market.
Blink is known for fast JavaScript performance (via V8), rapid feature rollout, and broad web-platform support, which is why developers often test against it first. The downside of that dominance is reduced engine diversity: when one engine controls most of the web, its quirks and decisions effectively become the de facto standard, whether or not the formal specifications agree.
Gecko (Firefox)
Gecko is Mozilla's open-source rendering engine, used by Firefox and its derivatives. Its market share is small — roughly in the single digits — but its role is outsized: Gecko is the main independent, non-Chromium engine on desktop, so it keeps the web from becoming a single-engine monoculture.
Gecko emphasizes web standards and privacy, and Mozilla's "Quantum" overhaul modernized its performance and parallelism. For developers, testing in Gecko is the most reliable way to catch places where a site has accidentally come to depend on Blink-specific behavior.
WebKit (Safari and all iOS browsers)
WebKit is Apple's engine, built from the older KHTML engine. It powers Safari on macOS and iOS, and is optimized for Apple hardware with an emphasis on battery efficiency and stability. On the desktop its share is modest, but on mobile it is very large because of one crucial rule.
On iOS and iPadOS, every browser must use WebKit — including "Chrome" and "Firefox" on iPhone. Those apps wrap Apple's WebKit rather than shipping Blink or Gecko, so on an iPhone you are always running WebKit no matter which browser icon you tap. This is why a site can render differently on iOS Chrome than on Android Chrome despite the same name.
Blink vs Gecko vs WebKit — comparison
| Engine | Maker | Approx. share | Powers | Known for |
|---|---|---|---|---|
| Blink | ~3/4 of desktop | Chrome, Edge, Opera, Brave | Speed, fast feature rollout, dominance | |
| Gecko | Mozilla | single digits | Firefox | Standards, privacy, engine independence |
| WebKit | Apple | small desktop, large mobile | Safari, all iOS browsers | Battery efficiency, stability |
The practical takeaway: most "different" browsers are really the same Blink engine wearing different interfaces, while Gecko and WebKit are the two genuinely distinct alternatives left.
A short history: KHTML → WebKit → Blink
The three engines are more related than they look. WebKit began in 2001 when Apple forked KHTML, the engine from the KDE project, to build Safari. For years WebKit powered both Safari and Google's Chrome. Then in 2013, Google forked WebKit to create Blink, so it could evolve the engine on its own terms. Gecko developed separately at Mozilla (and earlier Netscape) the whole time.
So Blink and WebKit share a common ancestor, which is why they sometimes behave similarly, while Gecko comes from an independent lineage.
How to check which engine your browser uses
The quickest way is to run BrowserInsight's browser kernel check, which detects the rendering engine your browser actually runs rather than trusting the name on the icon. That distinction matters because the user-agent string — the bit of text a browser sends to identify itself — is trivially editable. A browser can claim to be Chrome on Windows while actually being something else entirely.
This is exactly why engine detection looks past the user-agent to the engine's real behavior: which web APIs exist, how certain features are implemented, and other tells that are hard to fake. If you want to understand how that gap is exploited and detected, see how to detect user-agent spoofing, and for a deeper look at one engine-specific signal, how your GPU reveals your identity through WebGL.
Frequently Asked Questions
What browser engine does Microsoft Edge use?
Edge uses Blink, the same engine as Chrome. Microsoft retired its old EdgeHTML engine in 2020 and rebuilt Edge on Chromium, so today Edge and Chrome render pages almost identically; the differences are in the interface and built-in services, not the engine.
Is Chrome on iPhone really Chrome?
Not in the engine sense. On iOS, Apple requires every browser to use WebKit, so "Chrome" and "Firefox" on iPhone are interface skins over Apple's WebKit engine. They sync your data and look like the desktop apps, but the actual rendering is WebKit, which is why pages can behave differently than on Android.
What's the difference between a browser engine and a JavaScript engine?
The browser (rendering) engine lays out HTML and CSS into what you see; the JavaScript engine executes the page's scripts. They work together but are separate components — Blink pairs with V8, Gecko with SpiderMonkey, and WebKit with JavaScriptCore.
Can I change my browser's engine?
Not within a normal browser — the engine is built in. Your only practical choice is to switch browsers: pick a Chromium browser for Blink, Firefox for Gecko, or Safari for WebKit. On iOS this choice is removed entirely, since all browsers use WebKit.
Conclusion
Three engines — Blink, Gecko, and WebKit — render nearly the entire web, and the browser you pick is largely a choice among them. Blink dominates, Gecko keeps the web independent, and WebKit rules iOS by mandate. Knowing which engine you actually run matters for compatibility and privacy alike, and because the user-agent can misrepresent it, the only reliable way to know is to detect the engine's real behavior rather than trust its name.
Recommended Reading:
