How does this tool detect what web browser I am using?

Our diagnostic inspector evaluates two primary browser telemetry mechanisms: the legacy `navigator.userAgent` string and modern W3C User-Agent Client Hints (`navigator.userAgentData`). The tool parses vendor tokens, software release identifiers, and layout engine signatures (such as 'Edg/' for Microsoft Edge or 'Firefox/' for Mozilla Firefox) while cross-verifying underlying rendering capabilities and DOM features.

Why does my User-Agent string say Mozilla/5.0 and AppleWebKit when I use Chrome or Edge?

This is a historical quirk of web evolution known as User-Agent spoofing. In the early 1990s, Netscape Navigator (code-named Mozilla) supported advanced features like frames, leading webmasters to send advanced pages only to browsers declaring 'Mozilla'. Subsequent browsers—including Microsoft Internet Explorer, Apple Safari, and Google Chrome—prepended 'Mozilla/5.0' and 'AppleWebKit' to ensure legacy web servers did not downgrade or break their web experience.

Why does Windows 11 often report as Windows 10 in standard browser strings?

To prevent legacy enterprise websites and poorly coded JavaScript libraries from crashing when encountering a new major version number, Microsoft deliberately froze the standard User-Agent token for Windows 11 as 'Windows NT 10.0'. To accurately detect Windows 11, modern Chromium browsers deploy User-Agent Client Hints via `navigator.userAgentData.getHighEntropyValues()`. If the returned `platformVersion` is 13.0.0 or higher, the operating system is genuinely Windows 11.

What is a browser rendering engine and which one does my browser use?

A rendering engine (or layout engine) is the core software component that transforms HTML, CSS, JavaScript, and image assets into the visual interactive web pages you see on your screen. Today, the web is powered primarily by three major engines: Blink (developed by Google and used in Google Chrome, Microsoft Edge, Brave, Opera, and Vivaldi); Gecko (developed by Mozilla for Firefox); and WebKit (developed by Apple for Safari on macOS and iOS).

What is the difference between screen resolution and browser viewport size?

Screen resolution (such as 1920x1080 or 2560x1440) measures the total physical pixel grid of your monitor hardware. Browser viewport size represents the usable inner window area available for rendering web pages, excluding the browser's URL address bar, tab strip, bookmarks bar, vertical scrollbars, and the Windows taskbar or macOS dock. On high-DPI displays with operating system scaling (e.g. 150% scaling on a 4K laptop), viewport dimensions are also divided by the Device Pixel Ratio (DPR).

Why is it important to keep my web browser updated to the latest version?

Web browsers are the primary gateway between your personal computer and the open internet, making them the most targeted application for cyberattacks. Browser vendors release updates every two to four weeks containing critical zero-day security patches that fix remote code execution (RCE) flaws, sandbox escape vulnerabilities, and memory corruption bugs. Additionally, updates introduce support for modern CSS standards, WebGPU graphics pipelines, and faster JavaScript execution engines.

What is Do Not Track (DNT) and Global Privacy Control (GPC)?

Do Not Track (DNT) and Global Privacy Control (GPC) are HTTP header signals transmitted by your browser informing websites and third-party advertising networks that you do not consent to cross-site tracking or the selling of your personal browsing behavior. While compliance with legacy DNT was voluntary for web publishers, modern GPC is legally binding under data privacy statutes such as the California Consumer Privacy Act (CCPA) and European GDPR.

What is WebAssembly (Wasm) and why is it important?

WebAssembly (Wasm) is a low-level binary code format that executes inside modern web browsers at near-native hardware speed alongside JavaScript. It enables developers to compile performance-critical code written in C, C++, Rust, and Go to run directly in the browser. Technologies such as browser-based photo editing (Photoshop Web), 3D games (Unreal Engine Web), video rendering engines, and audio synthesizers rely heavily on WebAssembly for smooth real-time execution.

What's My Browser? Check Browser Version, Engine & OS

The Modern Web Browser: An Operating System Inside Your Operating System

Over the past three decades, the humble web browser has undergone a radical technological metamorphosis. What began in the early 1990s as a rudimentary text-and-hyperlink viewer (such as Tim Berners-Lee’s WorldWideWeb and NCSA Mosaic) has evolved into a massively sophisticated application runtime environment. Today’s web browser features dedicated multi-process sandboxing, hardware-accelerated 3D graphics rendering (WebGL and WebGPU), low-level binary compilers (WebAssembly), peer-to-peer media streaming (WebRTC), and complex cryptographic key stores.

In modern computing, your web browser is effectively a virtual operating system running on top of Windows 11, macOS, Linux, or ChromeOS.

Our What’s My Browser & Environment Inspector performs a deep, 100% client-side interrogation of your browser’s runtime environment, decoding User-Agent tokens, querying high-entropy platform hints, evaluating graphics APIs, and generating clean diagnostic specifications for remote support troubleshooting.

Anatomy of the User-Agent String: 30 Years of Web History

When your browser navigates to any URL, it transmits an HTTP request header known as User-Agent. For decades, this string served as the universal identification badge for client software. Consider a typical modern User-Agent string from a Windows 11 laptop running Microsoft Edge:

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0

To the untrained eye, this string appears nonsensical: Why does Microsoft Edge mention Mozilla, AppleWebKit, Chrome, AND Safari in a single line?

+--------------------------------------------------------------------------+
|                  ANATOMY OF A MODERN USER-AGENT STRING                   |
+--------------------------------------------------------------------------+
|                                                                          |
|  "Mozilla/5.0"                                                           |
|    |--> Historical compatibility token claiming Netscape compatibility   |
|                                                                          |
|  "(Windows NT 10.0; Win64; x64)"                                         |
|    |--> Operating System kernel version and 64-bit architecture token    |
|                                                                          |
|  "AppleWebKit/537.36 (KHTML, like Gecko)"                                |
|    |--> Layout engine ancestry: Blink branched from Apple's WebKit,      |
|         which itself originated from KDE's KHTML engine                  |
|                                                                          |
|  "Chrome/130.0.0.0 Safari/537.36"                                        |
|    |--> Indicates Chromium core codebase compatibility                  |
|                                                                          |
|  "Edg/130.0.0.0"                                                         |
|    |--> The TRUE vendor identity: Microsoft Edge build version 130       |
|                                                                          |
+--------------------------------------------------------------------------+

The Transition to User-Agent Client Hints (UA-CH)

Because the legacy User-Agent string grew bloated and provided a major vector for cross-site browser fingerprinting (tracking users across unrelated websites based on minor differences in plugins and version strings), the W3C and Chromium developers introduced User-Agent Client Hints.

Under this modern standard:

By default, browsers send only low-entropy hints: basic brand name and major version number (e.g. Chromium 130).
If a web application requires granular details (such as whether the host machine is running Windows 11 instead of Windows 10, or exact ARM64 vs x86-64 CPU architecture), it must explicitly request high-entropy values via the asynchronous JavaScript API: navigator.userAgentData.getHighEntropyValues(['platformVersion', 'architecture', 'bitness']).

Our diagnostic tool interrogates both traditional User-Agent tokens and modern Client Hints to ensure 100% accurate identification across all platforms.

The Big Three: Understanding Modern Layout Engines

While there are dozens of popular branded web browsers available today—including Google Chrome, Microsoft Edge, Brave, Opera, Vivaldi, Arc, Mozilla Firefox, and Apple Safari—virtually all of them are powered by one of three primary rendering engines:

+--------------------------------------------------------------------------+
|                    THE THREE GLOBAL RENDERING ENGINES                    |
+--------------------------------------------------------------------------+
|  Engine Name  | Primary Maintainer | Browsers Powered                    |
+---------------+--------------------+-------------------------------------+
|  Blink        | Google & Chromium  | Chrome, Edge, Brave, Opera,         |
|               | Open Source        | Vivaldi, Arc, Samsung Internet      |
|  Gecko        | Mozilla Foundation | Mozilla Firefox, Tor Browser,       |
|               |                    | Waterfox, Floorp                    |
|  WebKit       | Apple Inc.         | Safari (macOS / iOS),               |
|               |                    | All iOS third-party browsers        |
+---------------+--------------------+-------------------------------------+

1. Blink (Google Chromium)

Originally created by Google in 2013 as a fork of Apple’s WebKit (which itself forked from KHTML), Blink powers over 75% of global desktop and mobile web browsing. Blink pairs with the V8 JavaScript Engine, which utilizes multi-tiered Just-In-Time (JIT) compilation (Ignition interpreter and TurboFan optimizing compiler) to achieve phenomenal execution speeds for complex web applications.

2. Gecko (Mozilla Firefox)

Developed by the non-profit Mozilla Foundation, Gecko is an independent, standards-compliant layout engine written in C++ and Rust. Gecko is paired with the SpiderMonkey JavaScript engine and features Quantum, a parallelized multi-threaded CSS styling engine designed to prevent single heavy scripts from locking up the browser user interface.

3. WebKit (Apple Safari)

Maintained by Apple, WebKit is the default layout engine for macOS, iPadOS, and iOS. Powered by the JavaScriptCore (Nitro) engine, WebKit is renowned for exceptional energy efficiency and minimal battery drain on Apple Silicon hardware. Under Apple’s App Store guidelines, all third-party browsers running on iOS (including Chrome and Edge for iPhone) are legally required to use Apple’s underlying WebKit engine rather than their own.

Verifying Modern Web APIs: WebGL 2.0, WebGPU & WebAssembly

A critical function of our diagnostic tool is verifying whether your browser installation supports advanced hardware-accelerated web APIs:

WebGL 2.0: Based on the OpenGL ES 3.0 specification, WebGL 2.0 exposes low-level GPU rasterization, 3D texture mapping, transform feedback, and floating-point render targets directly to browser JavaScript via HTML5 Canvas elements.
WebGPU: The next-generation W3C graphics and compute standard designed to supersede WebGL. Built to interface directly with modern low-overhead native graphics APIs (DirectX 12 on Windows, Metal on Apple, and Vulkan on Linux/Android), WebGPU reduces CPU driver overhead, supports compute shaders for browser-based machine learning (such as WebLLM and Transformers.js), and unleashes desktop-grade graphics rendering in web tabs.
WebAssembly (Wasm): A compact binary instruction format designed as a portable compilation target for programming languages. Wasm enables high-performance execution of CAD suites (AutoCAD Web), Figma vector rendering, audio DAWs, and games inside the browser sandbox without third-party plugins.

Troubleshooting Browser Anomalies

If our diagnostic inspector detects anomalies or unexpected behavior in your browser:

Cookies Reported as Disabled: Many privacy extensions or strict tracking protection modes block third-party cookies by default. If first-party cookies are blocked, websites will be unable to maintain your login sessions or shopping cart states. In Chrome, check chrome://settings/cookies; in Firefox, navigate to Settings > Privacy & Security.
WebGL Reported as Unsupported: If WebGL shows as disabled, your browser may have disabled hardware graphics acceleration due to outdated or crashing GPU drivers. Navigate to your browser’s internal flags (such as chrome://flags or about:config) and ensure “Hardware Acceleration” is enabled, or update your graphics card drivers.
Viewport Size Mismatch: If your viewport dimensions appear smaller than your monitor specifications, check Windows Display Settings (Scale and layout). Windows 11 defaults to 125% or 150% scaling on high-resolution laptop panels to ensure text remains comfortable to read.
Cross-Verify System Hardware: For complementary hardware diagnostics, verify your display’s physical pixel grid with our Screen Resolution Checker, inspect operating system and CPU cores with our PC Specs Checker, check your public networking routing and IP leaks with What Is My IP, or evaluate WebGL 3D capabilities with our GPU Info Checker.

Modern Browser Security Architecture: Process Sandboxing and Site Isolation

Every modern web browser operates under the fundamental assumption that any arbitrary website you visit could contain malicious code. To prevent an infected web page from reading your local hard drive files, installing keyloggers, or snooping on passwords saved in adjacent browser tabs, modern browsers deploy multi-layered security sandboxes:

1. Multi-Process Architecture and Sandboxing

In early browsers, a single operating system process handled all open tabs, the rendering engine, and the user interface. A single crashing script crashed the entire browser. Today:

Browser Process: Manages the address bar, bookmarks, back/forward buttons, and network I/O.
Renderer Processes: Each open website runs inside an isolated, unprivileged OS child process. The renderer process has zero access to your physical disk drive, webcam, or microphone; it must request access via strictly validated Inter-Process Communication (IPC) messages sent to the main browser process.
GPU Process: Handles isolated 3D graphics compositing, isolating complex GPU drivers from the main user interface.

2. Site Isolation (Spectre Mitigation)

Introduced following the discovery of hardware CPU speculative execution vulnerabilities (Spectre and Meltdown), Site Isolation ensures that code from different web origins (e.g., bank.com and untrusted-site.com) never shares the same operating system renderer process or memory address space. Even if a malicious script exploits a speculative execution vulnerability inside the V8 or SpiderMonkey JavaScript engine, it cannot read memory buffers belonging to another active tab.

3. Transport Layer Security (TLS 1.3) and Certificate Pinning

Modern web browsers enforce encrypted HTTPS connections by default. Utilizing TLS 1.3 cryptographic handshakes, your browser verifies server authenticity using Public Key Infrastructure (PKI) X.509 digital certificates and encrypts all communications with forward secrecy (using ephemeral Elliptic Curve Diffie-Hellman key exchanges). This ensures that third parties eavesdropping on local public Wi-Fi networks cannot intercept passwords, session cookies, or personal browsing telemetry.

What's My Browser? Check Browser Version, Engine & OS