Chrome Memory Saver Mode (2026)

Q: Through Chrome Settings

Open chrome://settings/performance (or navigate to Settings → Performance) Toggle “Memory Saver” to enabled Click the gear icon to configure which sites are always active

Last updated: April 17, 2026

Chrome’s Memory Saver mode represents Google’s solution to one of the most common complaints from developers and power users: excessive memory consumption when running multiple tabs. This feature, formerly known as “Tab Groups” in earlier experimental forms, has evolved into a sophisticated memory management system that automatically pauses inactive tabs to free up RAM for your active work.

Understanding how Memory Saver works helps developers optimize their workflows, particularly when running memory-intensive development environments alongside browser-based tools, documentation, and testing interfaces.

How Memory Saver Mode Works

When you enable Memory Saver mode, Chrome monitors tab activity and automatically suspends tabs that haven’t been used for a configurable period. Suspended tabs release their memory footprint while preserving their state, when you return to a tab, Chrome restores it exactly as you left it.

The mechanism works by freezing page processes rather than terminating them. JavaScript execution pauses, network connections enter an idle state, and the page’s DOM snapshot gets stored in compressed form. This approach differs from simply closing tabs because:

State preservation: Scroll position, form inputs, and video playback position remain intact
Quick restoration: Resuming a tab takes milliseconds rather than loading from scratch
Resource efficiency: Memory usage drops to approximately 2-5MB per suspended tab versus 50-500MB for an active tab

For developers, this means you can keep documentation, API references, and debugging tools open without watching your RAM disappear.

Internally, Chrome uses the same “tab discarding” mechanism that the operating system’s low-memory pressure handler triggers automatically. Memory Saver puts this behavior under user control rather than waiting for the system to invoke it. When Chrome discards a tab proactively, it stores the tab’s serialized state in a compact representation on disk, which is why restoration is fast even on systems with limited RAM.

Enabling and Configuring Memory Saver

Through Chrome Settings

Open chrome://settings/performance (or navigate to Settings → Performance)
Toggle “Memory Saver” to enabled
Click the gear icon to configure which sites are always active

Programmatic Control with Chrome Flags

For testing or automated scenarios, Chrome provides flags to control memory behavior:

Launch Chrome with Memory Saver enabled by default
google-chrome --enable-features=MemorySaver
Disable memory optimization entirely
google-chrome --disable-features=MemorySaver
Adjust the inactivity threshold (in seconds)
google-chrome --memory-saver-interval-seconds=300
On macOS, use the full application path
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome \
 --enable-features=MemorySaver \
 --memory-saver-interval-seconds=600
Launch with a specific user data directory (useful for testing)
google-chrome \
 --user-data-dir=/tmp/chrome-test-profile \
 --enable-features=MemorySaver

Detecting Tab State in Extensions

If you’re building Chrome extensions, you can respond to tab suspension events:

chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
 if (message.type === 'tabStateChange') {
 // message.state is 'active', 'idle', or 'discarded'
 console.log(`Tab ${sender.tab.id} is now ${message.state}`);
 }
});
// In your manifest.json, declare the permission:
"permissions": ["tabs", "idle"]

You can also poll tab discard status directly using the tabs API:

// Check whether a specific tab has been discarded
async function isTabDiscarded(tabId) {
 const tab = await chrome.tabs.get(tabId);
 return tab.discarded;
}
// Listen for tabs being discarded
chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
 if (changeInfo.discarded === true) {
 console.log(`Tab ${tabId} (${tab.url}) was discarded by Memory Saver`);
 // Save any extension state associated with this tab
 saveTabExtensionState(tabId);
 }
});
// Restore state when a discarded tab becomes active again
chrome.tabs.onActivated.addListener(async ({ tabId }) => {
 const tab = await chrome.tabs.get(tabId);
 if (tab.url) {
 const savedState = await loadTabExtensionState(tabId);
 if (savedState) {
 restoreTabExtensionState(tabId, savedState);
 }
 }
});

Memory Saver and Development Workflows

Practical Impact for Developers

Running multiple instances of Chrome is common among developers, one for general browsing, another for testing, a third for development tools. Memory Saver becomes particularly valuable when:

Documentation Reference: Keep MDN, Stack Overflow, and framework docs suspended until needed. When you click a suspended tab, it restores instantly with your previous scroll position.

API Testing: Hold API documentation tabs in a separate window with Memory Saver disabled, while enabling it for reference materials in your main window.

CI/CD Monitoring: Suspended CI/CD dashboard tabs still show notification badges when builds complete, but consume minimal memory while you work in your IDE.

Multiple Staging Environments: Developers often keep tabs open for dev, staging, and production environments. Most of those tabs are idle most of the time. Memory Saver makes it practical to hold all three open without the combined memory cost of three fully loaded SPAs.

A Real Developer Tab Inventory

Here is a realistic inventory of browser tabs for a full-stack developer and the memory impact with and without Memory Saver:

Tab Category	Example	Active Memory	Suspended Memory
Framework docs	React docs	120 MB	3 MB
API reference	Stripe API docs	95 MB	2 MB
Issue tracker	GitHub Issues	180 MB	4 MB
CI dashboard	GitHub Actions	200 MB	4 MB
Dev environment	localhost:3000	350 MB	Always active
Staging app	staging.myapp.com	320 MB	Always active
Stack Overflow	Research tab	80 MB	2 MB
Figma (web)	Design file	600 MB	8 MB
Team chat	Slack web	400 MB	Always active
Email	Gmail	300 MB	Always active

With Memory Saver and four “always active” tabs, the suspended tabs drop from roughly 1.2 GB to about 23 MB, a substantial reduction when you also have an IDE, Docker, and a terminal running.

Interaction with Development Tools

Chrome DevTools interacts with Memory Saver in specific ways:

Open DevTools on a tab: Forces the tab to remain active, preventing suspension
Console preservation: Suspended tabs retain console history when restored
Network panel: Network requests are cleared on suspension but the tab state returns

This behavior matters when debugging, ensure your target tab is marked as “always active” in Memory Saver settings if you need uninterrupted debugging sessions.

You can verify whether DevTools is preventing suspension from the chrome://discards/ page. Tabs with DevTools open will show as “not discardable” in the urgency column, which confirms the protection is active.

Performance Benchmarks

Based on typical developer workflows, Memory Saver provides measurable improvements:

Scenario	Without Memory Saver	With Memory Saver
20 tabs open	2.8 GB	800 MB
50 tabs open	6.5 GB	1.2 GB
100 tabs open	12+ GB (swapping)	2.1 GB

Your actual results depend on the types of pages open. Tab-heavy sites like Gmail, Slack, and complex SPAs consume more memory when active but see the largest gains when suspended.

The performance benefit is compounded on machines with less RAM. On a MacBook with 8 GB, Chrome alone can consume 4-5 GB with a typical developer tab set, which pushes the system into swap territory. Swap on an SSD is tolerable but noticeably slower than RAM. Memory Saver can be the difference between a system that swaps constantly and one that stays in RAM for all active processes.

On a 16 GB machine the effect is less dramatic but still meaningful. IDE tooling like language servers, TypeScript compilation, and Webpack dev servers can easily consume 4-6 GB. Keeping Chrome under 2 GB while inactive tabs are suspended gives the rest of your toolchain room to breathe.

Measuring the Impact

You can measure Chrome’s memory consumption before and after enabling Memory Saver using built-in tools:

View Chrome's memory usage from the command line (macOS)
ps aux | grep -i chrome | awk '{sum += $6} END {print sum/1024 " MB"}'
More detailed breakdown by process type
ps aux | grep -i chrome | grep -v grep | \
 awk '{printf "%-60s %s MB\n", $11, $6/1024}' | sort -k2 -rn | head -20

You can also use chrome://memory-internals/ directly in Chrome, which shows a breakdown by process type including renderers, extensions, and the browser process itself. This is more accurate than the system process list because Chrome’s multi-process architecture spreads memory across dozens of processes that the ps command reports individually.

Advanced Configuration

Always Active Sites

Certain sites should never be suspended, your IDE’s web-based components, real-time dashboards, or communication tools:

// Add sites via preferences (for enterprise deployment)
const prefs = {
 "memory_saver_whitelist_sites": [
 "localhost:*",
 "*.google.com",
 "github.com"
 ]
};
chrome.settingsPrivate.setPreferences(prefs);

For personal configuration without enterprise policy deployment, the UI path is more practical. Navigate to chrome://settings/performance, enable Memory Saver, then click the “Add” button next to “Always keep these sites active.” The whitelist supports wildcard patterns so *.mycompany.com covers all subdomains.

Memory Pressure Handling

Chrome automatically engages aggressive memory management when system RAM runs low. You can monitor this behavior:

View memory statistics
chrome://memory-internals/
Check which tabs are suspended
chrome://discards/

The discards page shows exactly which tabs Chrome has suspended and why, helping you understand the memory management decisions.

The discards page columns are worth understanding:

Tab URL: The page that was or can be discarded
Visibility: Whether the tab is currently visible (visible tabs are never discarded)
Loading State: If the tab is still loading, it cannot be discarded
State: Active, hidden, or discarded
Urgency: How aggressively Chrome is willing to discard this tab (higher urgency = more likely to be discarded under memory pressure)
Reactivation Score: How recently this tab was active (higher score = Chrome will protect it longer)

Tabs that have been opened but never viewed have the highest urgency. Tabs you visited within the last few minutes have the lowest urgency and are protected first.

Scripting Tab Management

For developers who want automated tab management beyond what Memory Saver provides, the Chrome extension APIs offer more granular control:

// Extension: automatically discard tabs older than 30 minutes that aren't pinned
async function discardOldTabs() {
 const thirtyMinutesAgo = Date.now() - (30 * 60 * 1000);
 const tabs = await chrome.tabs.query({ active: false, pinned: false });
 for (const tab of tabs) {
 if (!tab.discarded && !tab.audible) {
 // Get last access time from session storage or track it yourself
 const lastAccess = await getTabLastAccess(tab.id);
 if (lastAccess < thirtyMinutesAgo) {
 await chrome.tabs.discard(tab.id);
 console.log(`Discarded tab: ${tab.title}`);
 }
 }
 }
}
// Track tab access times
const tabAccessTimes = {};
chrome.tabs.onActivated.addListener(({ tabId }) => {
 tabAccessTimes[tabId] = Date.now();
});
async function getTabLastAccess(tabId) {
 return tabAccessTimes[tabId] || 0;
}
// Run the cleanup every 10 minutes
setInterval(discardOldTabs, 10 * 60 * 1000);

This pattern is useful for power users who open dozens of research tabs and want automated cleanup without manually closing tabs or relying solely on Chrome’s built-in heuristics.

Troubleshooting

Pages Not Suspending

If specific pages never enter Memory Saver mode:

Check if the site is in your “always active” list
Verify the page doesn’t use WebSockets or Server-Sent Events (these prevent suspension)
Check chrome://discards/ for discardability status

Additional reasons a tab may not be discardable:

The tab is currently playing audio or was recently playing audio (audible tabs are protected)
The tab has an active form with unsaved input (Chrome protects against data loss)
The tab is pinned (pinned tabs are excluded from Memory Saver by default)
A Chrome extension has declared a keepalive for the tab
The tab has an active WebRTC connection (video call, screen share)

To diagnose a specific tab, open chrome://discards/, find the tab by URL, and read the “Urgency” column. If it shows “NEVER” or a very low urgency value, one of the above conditions is active.

Performance Regression

Some users report slower tab restoration on mechanical hard drives:

Switch to SSD storage for Chrome’s profile directory
Disable hardware acceleration if restoration stutters
Reduce the number of suspended tabs if restoration becomes noticeable

If restoration feels slow even on an SSD, it is caused by extensions that run content scripts on page load. Each content script executes when a discarded tab is restored. Extensions with heavy initialization code (password managers, ad blockers, development tools) can add measurable latency to restoration. You can test this by disabling extensions temporarily and measuring restoration time.

Memory Saver Not Reducing Usage

If you enable Memory Saver but do not see a meaningful reduction in Chrome’s total memory:

Check how many tabs are genuinely eligible for suspension. tabs with active DevTools, audio, WebRTC, or pinned status are all excluded
Verify that the inactivity threshold has elapsed. newly opened tabs are not immediately eligible
Look at extension memory usage separately in chrome://memory-internals/. extensions run in their own processes and are not affected by Memory Saver

Extensions are a frequently overlooked source of Chrome memory consumption. A single extension with a persistent background page can consume 50-200 MB independently of any tabs. Memory Saver does not touch extension processes, so an extension-heavy Chrome installation will not see the same gains as a lightweight one.

Building Extension Support for Memory Saver

Extensions can implement memory-aware behaviors:

// Detect when your extension's tab is about to be suspended
chrome.webNavigation.onBeforeNavigate.addListener((details) => {
 if (details.transitionType === 'auto_toplevel' &&
 details.url.startsWith('https://your-app.com')) {
 // Save critical state before potential suspension
 saveApplicationState();
 }
});

This ensures your web applications handle the suspension gracefully, persisting state before Chrome freezes the tab.

A more solid pattern uses the Page Lifecycle API, which gives explicit lifecycle hooks for the hidden, frozen, and discarded states:

// Listen for the page entering a frozen state (about to be discarded)
document.addEventListener('freeze', (event) => {
 // Synchronously save critical state. you have limited time here
 const state = captureApplicationState();
 sessionStorage.setItem('frozen-state', JSON.stringify(state));
 console.log('Page frozen, state saved');
});
// Listen for the page being resumed from frozen state
document.addEventListener('resume', (event) => {
 const savedState = sessionStorage.getItem('frozen-state');
 if (savedState) {
 restoreApplicationState(JSON.parse(savedState));
 sessionStorage.removeItem('frozen-state');
 console.log('Page resumed from frozen state');
 }
});
// Handle the case where a page is loaded after being discarded
// (document.wasDiscarded is true when restored from a discard)
if (document.wasDiscarded) {
 const savedState = sessionStorage.getItem('frozen-state');
 if (savedState) {
 restoreApplicationState(JSON.parse(savedState));
 }
}
function captureApplicationState() {
 return {
 scrollPosition: window.scrollY,
 formValues: captureFormValues(),
 uiState: getCurrentUiState(),
 timestamp: Date.now(),
 };
}

The freeze event fires synchronously when Chrome decides to freeze a tab. You have a short window to save state, avoid async operations here. The resume event fires when the tab becomes active again after freezing. And document.wasDiscarded is true on the next page load if the tab was fully discarded rather than just frozen.

Building this lifecycle awareness into web applications makes them resilient under Memory Saver and also in mobile browser environments where background tab management is even more aggressive.

Chrome’s Memory Saver mode is a practical tool for developers juggling numerous browser tabs alongside resource-intensive development environments. By understanding its mechanics and configuration options, you can maintain productivity without sacrificing system performance. The key is identifying which tabs genuinely need to remain active versus which can be suspended until needed.

Profiling Memory Usage Before and After Enabling Memory Saver

Before relying on Memory Saver’s automated behavior, establish a baseline to confirm it is actually helping your system. Chrome’s built-in Task Manager provides per-tab memory consumption data you can compare directly.

Open Chrome’s Task Manager with Shift + Esc (Windows/Linux) or through the menu at More Tools > Task Manager. Each open tab appears as a separate row with its current memory footprint. Sort by the Memory column to identify the heaviest consumers.

Record total memory usage across all tabs before enabling Memory Saver. Enable the feature, leave your tabs open and switch away from most of them for 10-15 minutes. Return to Task Manager and compare. Discarded tabs no longer appear in Task Manager. they have been released from memory entirely. The remaining active tab count, multiplied by their average footprint, represents your new working set.

For developers who want programmatic monitoring, Chrome DevTools exposes memory allocation data via the Performance tab’s timeline recorder:

// Snapshot heap usage in DevTools console
const memBefore = performance.memory.usedJSHeapSize;
// ... trigger some page actions ...
const memAfter = performance.memory.usedJSHeapSize;
console.log(`Heap delta: ${((memAfter - memBefore) / 1024 / 1024).toFixed(2)} MB`);

This measures the active tab’s heap rather than total process memory, but it confirms that a specific web application is not leaking memory even when it is the active tab that Memory Saver cannot discard.

For automated monitoring across sessions, the Chrome DevTools Protocol exposes Memory.getBrowserSamplingProfile which development tools can query programmatically. Combining CDP with your existing observability stack lets you track memory trends over days rather than just spot-checking.

Memory Saver and Progressive Web Apps

Progressive Web Apps (PWAs) installed in Chrome behave differently with Memory Saver than regular browser tabs. Because PWAs run in their own window context, separate from the main Chrome browser window, Memory Saver treats each installed PWA as a distinct application with its own lifecycle policy.

An installed PWA that your OS considers a “foreground app” will not be discarded by Memory Saver even when idle for extended periods. This distinction matters for developers testing PWA behavior. if your PWA maintains expected state after long idle periods, it is the PWA’s window focus state preventing the discard, not your service worker or cache strategy.

To test your PWA’s actual reload behavior, you can manually trigger a discard from chrome://discards. This page lists every loaded document (tabs and PWAs) and includes an “Urgent Discard” link that immediately frees the tab’s memory without waiting for Memory Saver’s heuristics.

After discarding your PWA via this tool, switch back to it and observe whether the service worker restores cached content correctly, background sync requests queued before the discard are replayed, and push notification registration persists across the discard/restore cycle. This manual testing workflow is faster than waiting for Memory Saver to trigger naturally and gives deterministic results for documenting your PWA’s offline and resume behavior.

You can also use the Page Lifecycle API to listen for discard events in your PWA’s service worker:

// In service worker: detect tab freeze/resume events
self.addEventListener('freeze', (event) => {
 // Persist any in-flight state before the process is frozen
 event.waitUntil(persistPendingData());
});
self.addEventListener('resume', () => {
 // Reinitialize connections after Memory Saver restores the tab
 reconnectWebSocket();
 refreshAuthToken();
});

Handling these events makes your PWA resilient to both Memory Saver discards and OS-level tab suspension, which is important for apps that maintain WebSocket connections or long-polling requests.

I'm a solo developer in Vietnam. 50K Chrome extension users. $500K+ on Upwork. 5 Claude Max subscriptions running agent fleets in parallel. These are my actual CLAUDE.md templates, orchestration configs, and prompts. Not a course. Not theory. The files I copy into every project before I write a line of code. **[See what's inside →](https://zovo.one/lifetime?utm_source=ccg&utm_medium=cta-default&utm_campaign=chrome-memory-saver-mode)** $99 once. Free forever. 47/500 founding spots left.