# Cross-Browser Testing with Playwright: What Chromium, Firefox and WebKit Reported About the Same Page

Dokimore Engineering Team · November 4, 2026, updated 2026-11-04 · 7 min read

Format: Original research · Written for: SDETs and automation engineers, Developers who own their tests, QA leads and test managers · Where it applies: every market

> Three engines loaded one page and were asked thirty questions about it. Most answers matched. The ones that did not are the ones a cross-browser suite exists to find, and two of them broke a test in a sibling guide.

## In short

- Engines agree on the web platform and differ on the edges: all three reported the same viewport (1280×720 at a device pixel ratio of 1), the same language and time zone, the same number and date formatting, native date and colour inputs, showPicker, the dialog element, :has(), CSS nesting, container queries and text-wrap: balance. A cross-browser suite does not need to re-test those.
- Where they differed: the user agent (WebKit on Linux reports a Macintosh), Firefox’s screen size (1366×768 against 1280×720), the default font family (Times New Roman, serif, -webkit-standard), WebGL (a software renderer in Chromium, none in headless Firefox, "Apple GPU" in WebKit), performance.memory (Chromium only), window.chrome (absent in headless Chromium), and the PDF viewer (WebKit only).
- Two differences changed test outcomes in the sibling guides: in WebKit a plain attachment link raised no download event, and a positional CSS selector cost 111 ms against 0.3 ms in Chromium. Run the download and the locator parts of a suite in WebKit if your users are on Safari; the rest can run once.

Cross-browser testing is expensive: three engines mean three times the minutes, and most of those minutes re-prove things the engines have agreed on for years. The useful question is where they still differ, because that is where the extra runs pay. So instead of asserting that they differ, we asked.

One fixture page, loaded in Playwright 1.62.1 under Chromium 151, Firefox 153 and WebKit 26.5, answered thirty questions through page.evaluate: what it is, what it can do, what it reveals about automation. The answers are below, along with the two differences that had already broken or distorted tests in the upload, download, debugging and selector guides run the same day.

## Where the three engines agreed

- Viewport 1280×720, device pixel ratio 1, no touch points, hardware concurrency 8: the Playwright defaults and the host, identical.
- Language en-US and time zone UTC, so 1,234,567.891 formatted as "1,234,567.891" and 4 November 2026 as "11/4/2026" in all three; a test that asserts a formatted date must set locale and timezoneId on the context, or it is asserting the runner’s settings.
- Native input types: date and color inputs stayed date and color (no fallback to text) and showPicker exists in all three. The dialog element exists in all three.
- CSS: :has(), native nesting, container queries and text-wrap: balance supported everywhere, so a layout test need not fear them.
- Scrollbar width 0 in all three headless engines, which means a layout that fits headless may lose 15 to 17 px to a classic scrollbar on a user’s desktop; test overflow with a forced scrollbar width, not with the headless default.
- The clipboard API object exists and navigator.webdriver is true in all three: a page can tell it is automated in every engine, which is why bot-detection evasion is not something a cross-browser run can promise.
- prefers-color-scheme: dark and prefers-reduced-motion: reduce were both false; to test those states, set colorScheme and reducedMotion on the context.

## Where they differed

None of the eight is a bug. Each is a place where a test can encode an assumption without noticing: a screenshot baseline taken in one engine’s default font, a WebGL feature test that passes only where a GPU is emulated, a PDF link that opens inline in one engine and downloads in another, a user-agent sniff in the product that treats the Linux WebKit build as a Mac. The value of the second and third engine is that they surface those assumptions once, at the cost of a run.

*The eight of thirty facts that differed, one page, measured 2026-11-04 with Playwright 1.62.1 in headless mode on Linux*

| Fact | Chromium 151 | Firefox 153 | WebKit 26.5 |
| --- | --- | --- | --- |
| navigator.userAgent | HeadlessChrome/151.0.7922.34 on X11; Linux x86_64 | Firefox/153.0 on X11; Linux x86_64 | Version/26.5 Safari/605.1.15 on "Macintosh; Intel Mac OS X 10_15_7" |
| navigator.platform | Linux x86_64 | Linux x86_64 | Linux x86_64 (the user agent says Macintosh; the platform does not) |
| screen.width × height | 1280×720 | 1366×768 | 1280×720 |
| Default body font-family (no CSS) | "Times New Roman" | serif | -webkit-standard |
| WebGL renderer | ANGLE, Vulkan 1.3, SwiftShader (software) | no WebGL context | Apple GPU |
| performance.memory | present | absent | absent |
| window.chrome | absent (headless) | absent | absent |
| navigator.pdfViewerEnabled | false | false | true |

## The two differences that changed test results

- **Downloads in WebKit.** In the [download guide](https://dokimore.com/blog/how-to-test-file-downloads-with-playwright), a click on a plain link to a Content-Disposition: attachment response raised no download event in WebKit in two runs, while the same link with the HTML download attribute raised one in 124 ms; Chromium and Firefox raised the event for the plain link every time. A download test green in Chromium said nothing about Safari.
- **Positional selectors in WebKit.** In the [selector guide](https://dokimore.com/blog/xpath-vs-css-selectors-for-test-automation), li:nth-child(7777) > button took a median 111 ms in the page in WebKit against 0.3 ms in Chromium and 1 ms in Firefox, and 390 ms through the Playwright locator round trip. A suite built on positional selectors is slow in one engine and fragile in all three.
- **What did not differ**, from the same day’s runs: file uploads by path, by buffer and through the file chooser behaved identically; a login through the form, a saved session and an API login behaved identically; Playwright’s timeout call logs for a missing locator and a covered button were word-for-word the same in all three engines.

## A cross-browser plan that spends minutes where they count

- Run the full suite in one engine on every change: Chromium, usually, because it is where most users are and most runners are fast.
- Run in all three, at least daily and before a release, the tests that touch downloads, native inputs, layout with fonts, media, WebGL or canvas, and anything that sniffs the user agent.
- Keep screenshot baselines per engine; the default font alone makes a shared baseline impossible.
- Set locale, timezoneId, colorScheme and reducedMotion on the context explicitly; the agreement above is the runner’s default, not your users’.
- Treat a WebKit-only failure as a finding about Safari, not as flakiness: the two above were deterministic.

## How Dokimore runs the engines

The [recorder](https://dokimore.com/product/test-recorder) replays on five engines, Chromium, Chrome, Firefox, WebKit and Edge, and on Team and above runs them in parallel on the execution grid; scheduled folder runs use Chromium. A run keeps a screenshot per step per engine, which is where a default-font difference or a download that never fired shows up as a visible step rather than a silent pass. Exported Playwright code carries the same engines as projects in your own configuration.

## What to do next

1. Run the download, native-input, font-dependent and user-agent-dependent tests in all three engines before the next release; run the rest in one.
2. Set locale, timezoneId, colorScheme and reducedMotion on every context so the suite asserts your users’ settings, not the runner’s.
3. Keep one screenshot baseline per engine; the default fonts differ in all three.
4. Search the product for user-agent sniffing; the Linux WebKit build identifies as a Mac in its user agent and as Linux in navigator.platform.
5. Reproduce the thirty questions on your own page with the linked script and keep the answers as a per-engine fact sheet.

## Questions people ask

### Does Playwright test real Safari?

It drives WebKit, Safari’s engine, on Linux, Windows and macOS. That catches engine-level differences, two of which changed test results in our runs, but it is not Safari itself: the user agent said Macintosh while navigator.platform said Linux, and the browser chrome and extensions are absent. A release still deserves a check in real Safari.

### How different are Chromium, Firefox and WebKit really?

On our page, 22 of 30 facts matched: viewport, locale, time zone, formatting, native inputs, dialog, showPicker, modern CSS. The eight that differed were the user agent, Firefox’s screen size, the default font, WebGL, performance.memory, window.chrome and the PDF viewer, plus the download and positional-selector behaviours the sibling guides found.

### Which tests should run in every browser?

The ones that touch what differs: downloads, native inputs, font-dependent layout and screenshots, media, WebGL or canvas, and any code that reads the user agent. Uploads, logins, API calls and Playwright’s own waiting behaved identically across the three engines in our runs and can run once.

### Why does my screenshot test fail in one browser only?

Most often the default font: with no CSS the body rendered in Times New Roman in Chromium, serif in Firefox and -webkit-standard in WebKit. Keep a baseline per engine, pin fonts in the page, and remember headless scrollbars are 0 px wide in all three while a desktop scrollbar is not.

## How we measured this

- Run on 2026-11-04 with Playwright 1.62.1 and its pinned builds (Chromium 151.0.7922.34, Firefox 153.0, WebKit 26.5), headless, inside the image that carries those builds, networking disabled, fixture page on 127.0.0.1. Scripts and raw output: docs/marketing/keyword-research/research/playwright-guides-2026-11-04 (e6-browsers.js, out/e6-browsers.json).
- The thirty facts are the values a single page.evaluate returned for each engine with a default context (no locale, timezone, viewport or device options). The count of agreements and differences is over those values; "agreed" means byte-identical. The two behavioural differences are cross-referenced from the same day’s download and selector runs.
- Dokimore’s behaviour is the product code on the article date: five engines in the recorder, parallel execution on the grid at Team and above, Chromium for scheduled folder runs, a screenshot per step per engine.

## Sources

1. [Playwright documentation, Browsers: Chromium, Firefox and WebKit builds pinned per release, plus Chrome and Edge channels](https://playwright.dev/docs/browsers) (read 2026-11-04)
2. [MDN, HTMLInputElement.showPicker(): Baseline widely available since September 2022, which our three engines confirmed](https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/showPicker) (read 2026-11-04)
3. [Playwright release notes: 1.64 is current on the date of this run (Chromium 156, Firefox 157, WebKit 27.2); the platform pins 1.62.1, so the engine versions above are those](https://playwright.dev/docs/release-notes) (read 2026-11-04)

Source: https://dokimore.com/blog/cross-browser-testing-with-playwright-chromium-firefox-webkit
