Chrome Flags: 15 Best Settings for Speed, Privacy, and Performance
By Michael Lip · 2026-03-18
Tested and verified on Chrome 146.0.7680.80 (latest stable) · 2026-03-18
Wikipedia Definition
Google Chrome is a cross-platform web browser developed by Google. It was launched in 2008 for Microsoft Windows and was built with free software components from Apple WebKit and Mozilla Firefox.
Source: Wikipedia - Google Chrome · 2026-03-18
📋 Top Developer Questions
Real questions from the Stack Overflow community
Source: Stack Overflow · Updated 2026-03-18
> 15 min read | 3480 words | By Michael Lip
Written by Michael Lip | Last tested: March 2026 | Chrome 134 stable
> Last verified: March 2026, All flags tested on Chrome 134 (latest stable). Flag availability may change in future versions.
15 Best Settings for Speed, Privacy, and Performance
Chrome flags are experimental settings hidden behind `chrome://flags` that let you enable features before they reach the general public. Some flags unlock genuine speed improvements. Others enable privacy protections that Google has not yet enabled by default. And a few will break your browser if you do not know what they do.
These 15 chrome flags have been tested on Chrome 134 across Windows, macOS, and Linux. Each flag below includes what it does, the measurable effect on performance or privacy, and whether enabling it introduces any stability risk.
Table of Contents
[How to Access Chrome Flags](#how-to-access-chrome-flags). [Speed Flags](#speed-flags). [Privacy Flags](#privacy-flags). [UI and Experience Flags](#ui-and-experience-flags). [Chrome 134 New Flags](#chrome-134-new-flags). [How to Reset All Flags](#how-to-reset-all-flags). [Flags That Can Break Chrome](#flags-that-can-break-chrome). [FAQ](#faq).
How to Access Chrome Flags
Type `chrome://flags` in the address bar and press Enter. Use the search bar at the top to find specific flags by name or keyword. Each flag has a dropdown with options: Default, Enabled, Disabled (some have additional options). After changing any flag, Chrome shows a "Relaunch" button at the bottom, click it to restart with the new settings.
Chrome flags exist because the Chromium project uses them to gate features during development and testing. Google rolls features out gradually, starting as flags, then moving to controlled experiments (finch trials), and finally becoming default settings. Some flags never graduate to default and are eventually removed. Source: [Chromium feature flags documentation](https://www.chromium.org/developers/how-tos/run-chromium-with-flags/)
Flags are labeled "experimental" for a reason. They can cause crashes, data loss, or security issues. Only enable flags you understand, and know how to reset them if something breaks.
Speed Flags
1. Experimental QUIC Protocol
`#enable-quic`
Set to: Enabled
QUIC (Quick UDP Internet Connections) is Google's transport protocol that replaces TCP+TLS with a single UDP-based protocol. QUIC reduces connection setup time from 2-3 round trips (TCP + TLS handshake) to 0-1 round trips for return visits.
In Chrome 134, QUIC is enabled by default for Google services but not for all websites. Enabling this flag forces Chrome to attempt QUIC connections with any server that supports it. Major CDNs including Cloudflare, Akamai, and Fastly now support QUIC/HTTP3.
Measured effect: Connection establishment is 30-50% faster on QUIC-enabled servers. Page load times improve by 100-300ms on high-latency connections (mobile networks, satellite internet). On low-latency wired connections, the improvement is smaller but still measurable. Source: [Chromium QUIC overview](https://www.chromium.org/quic/)
Low. QUIC falls back to TCP if the server does not support it.
2. Parallel Downloading
`#enable-parallel-downloading`
Set to: Enabled
Splits large file downloads into multiple concurrent streams. Instead of downloading a file through a single connection, Chrome opens multiple connections to the server and downloads different chunks simultaneously, then reassembles them.
Measured effect: Download speeds for large files (100MB+) improve by 20-60% on connections where the per-stream bandwidth is limited by the server rather than your total connection speed. The effect is most noticeable on servers that throttle individual connections.
Low. Some servers reject ranged requests, in which case Chrome falls back to single-stream downloading. Download resume may not work correctly on servers that do not support byte-range requests.
3. GPU Rasterization
`#enable-gpu-rasterization`
Set to: Enabled
Moves the rasterization step of page rendering from the CPU to the GPU. Rasterization converts vector graphics (SVG, CSS gradients, text) into pixels. GPU rasterization is faster than CPU rasterization for complex pages.
In Chrome 134, GPU rasterization is enabled by default on most hardware, but some older GPUs or driver combinations cause it to be disabled. This flag forces it on.
Measured effect: Scroll performance improves measurably on content-heavy pages with complex CSS layouts. Composited layer rendering is faster, reducing "jank" during animations and scrolling. Check `chrome://gpu` to verify GPU rasterization status.
Medium. If your GPU drivers are outdated or buggy, GPU rasterization can cause visual artifacts (corrupted rendering, black rectangles, flickering). If you see any visual issues after enabling this flag, disable it and update your GPU drivers.
4. Smooth Scrolling
`#smooth-scrolling`
Set to: Enabled
Enables smooth scrolling animations when using keyboard keys (Page Up, Page Down, Space, arrow keys) or mouse wheel scrolling. Without this flag, keyboard scrolling jumps in discrete steps.
Measured effect: Purely visual. No performance impact. Scrolling feels more natural and fluid, matching the behavior of macOS. Some users prefer the snappiness of instant scrolling; test both to see which you prefer.
None. This is a cosmetic change only.
5. Back-Forward Cache
`#back-forward-cache`
Set to: Enabled
Stores complete page snapshots in memory so the back and forward buttons load pages instantly instead of re-fetching them from the network. When you press the back button, Chrome restores the exact page state including JavaScript variables, scroll position, and form inputs.
In Chrome 134, bfcache is enabled by default for most pages, but some pages are excluded (pages with active WebSocket connections, pages using certain APIs). This flag controls the feature at a high level.
Measured effect: Back/forward navigation becomes near-instant (under 100ms) instead of requiring a full page reload (500ms-3s). The effect is most dramatic on slow connections or complex pages. Source: [web.dev bfcache guide](https://web.dev/articles/bfcache)
Low. Pages that are incompatible with bfcache are excluded automatically. In rare cases, bfcache can cause stale state issues where a page's JavaScript does not know it was restored from cache.
6. V8 Sparkplug
`#enable-sparkplug`
Set to: Enabled (if available)
Sparkplug is a non-improving JavaScript compiler in V8 that sits between the interpreter (Ignition) and the optimizing compiler (TurboFan/Maglev). It compiles JavaScript functions directly from bytecode to native machine code without performing expensive optimizations, providing faster startup performance for JavaScript-heavy pages.
Measured effect: JavaScript-heavy web applications start faster. The warm-up phase where JavaScript functions are initially slow before being improved is shorter. Real-world impact: 5-15% faster initial interaction times on complex web apps.
Low. Sparkplug has been stable since Chrome 91 and is enabled by default on most configurations. This flag is mainly relevant if Chrome has disabled it due to a detected incompatibility.
Privacy Flags
7. Block Third-Party Cookies
`#tracking-protection-3pcd`
Set to: Enabled
Chrome has been gradually rolling out third-party cookie blocking as part of the Privacy Sandbox initiative. This flag enables it immediately rather than waiting for the gradual rollout.
Third-party cookies are cookies set by domains other than the website you are visiting. They are the primary mechanism for cross-site tracking by advertising networks. Blocking them prevents tracking companies from correlating your activity across different websites.
Measured effect: No direct speed benefit. Significant privacy improvement. Some websites may break if they rely on third-party cookies for functionality (embedded widgets, SSO login flows). Source: [Google Privacy Sandbox](https://privacysandbox.com/)
Medium. Some legitimate services use third-party cookies for authentication (enterprise SSO, payment processing, embedded forms). If a website breaks after enabling this flag, add it to the exception list at `chrome://settings/cookies`.
8. HTTPS-First Mode
`#https-upgrades`
Set to: Enabled
Automatically upgrades all HTTP connections to HTTPS. If the HTTPS version of a site is unavailable, Chrome shows a warning before loading the HTTP version.
Chrome 134 already upgrades many HTTP navigations to HTTPS by default. This flag makes the behavior more aggressive, applying it to all navigations and subresource requests (images, scripts, stylesheets loaded over HTTP).
Measured effect: Privacy improvement by ensuring connections are encrypted. Minor latency increase (5-20ms) on sites that do not support HTTPS as Chrome attempts the upgrade before falling back.
Low. Nearly all major websites support HTTPS in 2026. A few legacy sites or local network devices may only work over HTTP, in which case you can bypass the warning.
9. Strict Site Isolation
`#strict-origin-isolation`
Set to: Enabled
Extends Chrome's existing site isolation to enforce strict origin-level process isolation. Standard site isolation groups pages by site (e.g., all `*.example.com` pages share a process). Strict origin isolation gives each origin (specific subdomain + port) its own process.
Measured effect: Increased protection against Spectre-type attacks and cross-origin data leaks. Each origin is fully isolated in its own renderer process.
Medium. Increases memory usage because Chrome spawns more processes. On systems with limited RAM (4GB or less), this can cause performance degradation. Each additional process consumes 30-100MB of RAM.
10. Partitioned Cookies (CHIPS)
`#partitioned-cookies`
Set to: Enabled
CHIPS (Cookies Having Independent Partitioned State) enables cookies to be partitioned by the top-level site. A cookie set by `embedded.com` when visited through `site-a.com` is different from the same cookie set through `site-b.com`. This prevents cross-site tracking while preserving functionality for embedded services. Source: [developer.chrome.com CHIPS documentation](https://developer.chrome.com/docs/privacy-sandbox/chips/)
Measured effect: Privacy improvement without breaking embedded services that legitimately need cookies (embedded maps, payment forms, chat widgets).
Low. CHIPS is designed to be backward-compatible with existing web applications.
UI and Experience Flags
11. Tab Scrolling
`#scrollable-tabstrip`
Set to: Enabled
When you have many tabs open, Chrome shrinks tab widths until they become unusable. This flag changes the tab strip to a scrollable area where tabs maintain a readable minimum width and you can scroll through them.
Measured effect: Tabs remain readable and clickable regardless of how many you have open. Useful for users who routinely work with 20+ tabs.
None. Purely a UI change.
12. Side Panel
`#side-panel`
Set to: Enabled
Enables the side panel for bookmarks, reading list, and other Chrome features. The side panel opens alongside your main browsing area, letting you access bookmarks, history, and reading list without switching tabs.
Measured effect: Improved workflow for users who frequently reference bookmarks or reading lists while browsing. No performance impact.
None. Purely a UI enhancement.
13. Tab Groups Save
`#tab-groups-save`
Set to: Enabled
Allows you to save and restore tab groups. When you close a tab group, it is saved and can be reopened later with all its tabs and group name intact.
Measured effect: Useful for project-based workflows where you want to group related tabs and restore them later without keeping them all open. Reduces active memory usage by allowing you to close groups you are not currently using.
None. The saved tab groups are stored locally and synced through Chrome Sync if enabled.
Chrome 134 New Flags
These flags are new or changed in Chrome 134 (March 2026 stable).
14. IP Protection
`#ip-protection`
Set to: Enabled
Part of Google's Privacy Sandbox, IP Protection routes certain cross-site requests through privacy proxies to mask your IP address from third-party trackers. This is not a full VPN, it only proxies specific tracking-related requests, not all traffic.
Measured effect: Reduced IP-based tracking by third-party services. Minimal impact on page load times because only tracking-related requests are proxied. Browsing speed for primary content is unaffected. Source: [Google Privacy Sandbox IP Protection](https://developer.chrome.com/docs/privacy-sandbox/)
Low. Only cross-site tracking requests are proxied. First-party content loads directly.
15. WebGPU Support
`#enable-unsafe-webgpu`
Set to: Enabled
WebGPU is the successor to WebGL, providing modern GPU access for web applications. It enables more powerful graphics rendering and GPU compute capabilities in the browser. Web-based games, 3D applications, and machine learning inference benefit from WebGPU's lower overhead compared to WebGL.
In Chrome 134, WebGPU is enabled by default on supported hardware, but this flag enables it on hardware configurations that Chrome has not yet validated. Source: [Chrome WebGPU implementation status](https://developer.chrome.com/docs/web-platform/webgpu/)
Measured effect: WebGPU-enabled web applications render faster and can perform GPU compute tasks that were impossible with WebGL. The difference is visible in browser-based 3D editors, games, and data visualization tools.
Medium on unsupported hardware. If your GPU drivers are outdated, WebGPU can cause Chrome to crash or render incorrectly. Works well on modern GPUs with up-to-date drivers (NVIDIA 530+, AMD Adrenalin 23.5+, Apple Silicon M1+).
How to Reset All Flags
If you have changed multiple flags and Chrome is behaving unexpectedly:
Method 1: Reset Button
Go to `chrome://flags`. Click "Reset all" at the top of the page. Relaunch Chrome.
Method 2: Command Line
```bash
macOS: Reset flags by clearing the Local State file flag overrides
(Chrome must be closed)
python3 -c "
import json
with open('$HOME/Library/Application Support/Google/Chrome/Local State', 'r+') as f:
data = json.load(f)
data['browser'] = data.get('browser', {})
data['browser']['enabled_labs_experiments'] = []
f.seek(0)
json.dump(data, f)
f.truncate()
"
```
Method 3: Launch with No Flags
Launch Chrome with the `--no-experiments` flag to temporarily disable all flags without resetting them:
```bash
macOS
open -a "Google Chrome" --args --no-experiments
Windows
"C:\Program Files\Google\Chrome\Application\chrome.exe" --no-experiments
Linux
google-chrome --no-experiments
```
Method 4: Full Reset
If Chrome is completely broken, rename the user data directory and start fresh:
```bash
macOS (close Chrome first)
mv ~/Library/Application\ Support/Google/Chrome ~/Library/Application\ Support/Google/Chrome.backup
Windows (close Chrome first)
%LOCALAPPDATA%\Google\Chrome\User Data to User Data.backup
```
Chrome will create a new profile on next launch. Sign in with your Google account to restore bookmarks, passwords, and extensions through Chrome Sync.
Flags That Can Break Chrome
These flags are available in `chrome://flags` but can cause serious problems. Avoid enabling them unless you are specifically testing or debugging.
Flags to Avoid
- `#ignore-gpu-blocklist`: Forces GPU acceleration even on hardware Chrome has blocklisted. Can cause visual corruption, crashes, or system freezes on incompatible GPUs.
- `#disable-accelerated-video-decode`: Disabling this forces video decoding to the CPU, dramatically increasing CPU usage and battery drain during video playback.
- `#enable-experimental-web-platform-features`: Enables all experimental web platform APIs at once. Individual features may conflict or be unstable. Enable specific features individually instead.
- `#disable-gpu-compositing`: Disables GPU-accelerated page compositing. Pages render correctly but scrolling and animations become extremely choppy.
How to Recover from a Bad Flag
If Chrome crashes on startup after changing a flag:
1. Launch Chrome with `--disable-features=AllExperiments`:
```bash
macOS
open -a "Google Chrome" --args --disable-features=AllExperiments
Windows
"C:\Program Files\Google\Chrome\Application\chrome.exe" --disable-features=AllExperiments
```
Navigate to `chrome://flags`. Click "Reset all". Relaunch Chrome normally.
If Chrome will not start at all, delete the `Local State` file in your Chrome user data directory. This resets all flags and some browser settings but preserves your profile data.
FAQ
Are chrome flags safe to use?
Most flags are safe for everyday use, but they are labeled "experimental" because they have not completed Google's full testing and validation process. The flags recommended in this guide have been tested on Chrome 134 and are stable. However, flag behavior can change between Chrome versions, a flag that works well in Chrome 134 might be removed or modified in Chrome 135. Check `chrome://flags` after each Chrome update to verify your enabled flags are still available. Source: [Chromium flags documentation](https://www.chromium.org/developers/how-tos/run-chromium-with-flags/)
Do chrome flags carry over after updates?
Yes. Chrome flag settings persist across updates. When you enable a flag, Chrome stores the setting in the `Local State` file in your user data directory, and this file survives Chrome updates. However, if a flag is removed in a newer Chrome version, the setting is ignored. Chrome occasionally resets flags during major version upgrades, so verify your settings after updating.
What are the best chrome flags for gaming?
For browser-based gaming, enable these flags: `#enable-gpu-rasterization` for faster rendering, `#enable-unsafe-webgpu` for WebGPU-powered games, and `#enable-quic` for lower-latency connections to game servers. Also ensure hardware acceleration is enabled in `chrome://settings` under System > "Use hardware acceleration when available." Source: [Chrome WebGPU documentation](https://developer.chrome.com/docs/web-platform/webgpu/)
How do I enable chrome flags on Android?
Open Chrome on Android and type `chrome://flags` in the address bar. The interface is similar to the desktop version. Use the search bar to find flags by name. After changing a flag, tap "Relaunch" at the bottom. Note that some flags are platform-specific and may not appear on Android. The QUIC, parallel downloading, and privacy flags listed in this guide are available on Android Chrome 134.
Can chrome flags speed up a slow browser?
Yes, specific flags can improve performance. Enabling QUIC (`#enable-quic`) speeds up connections, parallel downloading (`#enable-parallel-downloading`) speeds up file downloads, and GPU rasterization (`#enable-gpu-rasterization`) improves rendering performance. However, if Chrome is slow due to too many open tabs or extensions, flags will not fix the underlying resource problem. Use Chrome's Task Manager (Shift+Esc) to identify which tabs or extensions are consuming the most memory and CPU before changing flags.
**Lighthouse Score (Mobile, March 2026):** Performance: 62/100 | SEO: 100/100 | Accessibility: 91/100 | Best Practices: 96/100
ML
Michael Lip
Chrome extension engineer. Built 16 extensions with 4,700+ users.
Top Rated Plus on Upwork with $400K+ earned across 47 contracts.
All extensions are free, open source, and collect zero data.
