I measured which browser really eats the most RAM, and the meme is out of date

We’ve all done it at least once. I at least know that I’ve repeated the old joke over and over that Chrome eats more RAM than a puppy left alone with treats. For years, Google Chrome’s excessive memory usage has slowly morphed from a meme into accepted wisdom.

But modern Chrome now reclaims memory far more aggressively than it once did, thanks to tracker blocking and split workloads. Somehow, despite these innovations and an adequate 16GB of RAM, browsing the internet in Chrome still brings my laptop to a crawl.

So I went on the hunt for a new browser and wanted to benchmark the top five with something more convincing than Task Manager. I ended up building a clean Windows 11 virtual machine in ESXi with 8GB of RAM, installed only five browsers, and created a PowerShell script to test their resource usage when no profiles, signed-in accounts, or extensions were in use.

As it turns out, Chrome was not the worst. It wasn’t even particularly close.

I built a better test than Task Manager could give me

One glance at memory usage was never going to settle this properly

Windows Task Manager is useful for a quick glance at what’s eating up resources, but thanks to grouping processes together, it kind of sucks as a benchmarking tool. Since browser RAM usage also rises and falls as pages finish loading, judging performance at the wrong moment gives me a temporary spike or lull at best.

Another issue is that modern browsers split their work across processes. There are separate ones for tabs, networking, graphics, and the interface itself. With Chrome specifically, inactive tabs can even be put to sleep to free up memory. Looking at one process tells me almost nothing. At the same time, simply adding the working-set figures might count shared memory more than once.

So, when I built my browser benchmarking tool in PowerShell, I aimed to collect every process belonging to the browser under test:

$Processes = Get-Process -Name $ProcessNames 

The script then matched these processes against Windows performance data and added their private working sets together:

$PrivateWorkingSetBytes = ($PerfRows | Measure-Object WorkingSetPrivate -Sum).Sum 

“Private working set” is the physical RAM used by these browser processes, so this became my main measurement. The script also recorded:

• Private bytes
• Total working set
• Process count
• Average usage
• Median usage
• The 95th percentile
• Highest peak

Every single reading was written to a CSV file so that I could check the raw data and build useful graphs later on.

Since, on average, I run around 10 tabs in my browser, my script ran these 10 websites in the same order each time, for each test:

$Everyday10Sites = @(
    'https://www.makeuseof.com/'
    'https://en.wikipedia.org/wiki/Web_browser'
    'https://www.reddit.com/'
    'https://www.youtube.com/'
    'https://www.google.com/maps'
    'https://github.com/microsoft/PowerShell'
    'https://www.amazon.com/'
    'https://www.bbc.com/news'
    'https://www.office.com/'
    'https://www.canva.com/'

The script allowed a generous two minutes for the pages to load, then sampled the browser’s memory every two seconds for five minutes. I repeated the same test three times for these five popular browsers on their out-of-the-box default settings:

• Chrome
• Edge
• Firefox
• Brave
• Opera

Finally, I used the median from those three runs:

$FinalMedian = Get-Median -Values $RunMedians

Using the median value stopped one brief spike from poisoning the results and deciding the winner.

Chrome did not come close to using the most RAM

Firefox stayed heaviest, while Brave wasn’t even in the same ballpark

After testing, the official three-run medians came in at:

Chrome was a huge surprise because I honestly expected a high-memory showdown between it and Edge. Instead, Chrome finished second, behind the privacy-focused Brave browser. Its median was around 558MB lower than Firefox, which roughly worked out to be 28% less RAM.

That’s the Chrome RAM-eating meme disproven right there.

OS

Windows, macOS, Linux, Android, iOS/iPadOS, ChromeOS

Developer

Google LLC

Google Chrome is a cross-platform web browser developed by Google LLC, built for speed, security, and integration with Google services. It uses the Blink rendering engine (formerly WebKit) and supports extensions, tab sandboxing, synchronization across devices, and frequent updates.

Microsoft’s browser Edge fared worse than Chrome, despite being based on Chromium. Its median was 367MB higher, and it averaged roughly 62 processes compared with Chrome’s 53. It was also less consistent across the three tests, with a 389MB spread between its highest and lowest runs.

OS

Windows, Android, iOS

Developer

Microsoft

Microsoft Edge is Microsoft’s web browser, built for fast browsing, built-in security, and tight Windows integration. It also includes Copilot features that help with search, summaries, and other everyday web tasks.

Firefox turned out to be the heaviest sustained user in my test, which came as no surprise to me. Firefox’s three benchmarking runs were super consistent and stayed quite close together with a spread of 203.2MB. That doesn’t mean that Firefox manages memory worse than the others. It just groups more work into fewer, larger processes instead of aggressively splitting the workload as Chromium browsers do.

OS

Windows, macOS, Linux, Android, iOS

Price model

Free

Firefox is a free, open-source web browser developed by Mozilla, focused on speed, privacy, and security for users on all major platforms. It includes advanced features like tabbed browsing, a built-in password manager, private browsing mode, strong tracker blocking, and customization through thousands of extensions and themes.

Opera was the opposite. In fact, its results fluctuated so much that I ran the benchmarking script a further three times to make sure it wasn’t a one-off. Opera’s RAM usage fluctuated between 1.65GB and 2.56GB, with the highest peak at 2.93GB.

OS

Windows, macOS, Linux Android, iOS

Developer

Opera

Opera is a feature-rich, Chromium-based web browser designed for productivity. It features a built-in VPN, native ad blocker, and a sidebar for instant access to messaging apps. With unique modular tabs and integrated AI assistants, Opera prioritizes privacy, customization, and seamless multitasking across both desktop and mobile devices.

Then there was Brave, and it barely looked like it was even running the same workload. Its official median was less than half of Chrome’s, and a fourth run of the benchmarking script somehow came in even lower, at 644.6MB. Each run had similar amounts of processes running, with an average of 18, so it definitely wasn’t a fluke repeated four times.

OS

Windows, macOS, Linux, Android, iOS

Developer(s)

Brave

Brave is an open-source web browser focused on privacy, speed, and user control. Its standout features include Shields, which block ads, trackers, cookies, fingerprinting, and more by default, giving users granular privacy protection without the need for extensions. 

The results say as much about browser defaults as browser engines

Blocking, sleeping, and background behavior changed the workload

Interestingly, Chrome, Edge, Brave, and Opera all use Chromium, the open-source codebase developed by Google. Yet strangely, their memory results were nowhere near identical. That’s because the underlying Chromium engine is wrapped in its own collection of privacy tools, features, background services, and memory-saving functionality.

Brave’s result really drives this home. Brave shields us from most ads and their trackers out of the box. Fewer advertising scripts and embedded elements should, in theory, mean less work for the browser and subsequently less RAM usage. Still, I myself can’t claim that blocking alone accounts for such a huge difference.

Edge and Opera add a bit more to the basic browsing experience. Edge offers extensive Microsoft integrations and performance features, while Opera provides quick access to extensions and other tools.

Firefox is the only browser I tested that uses its own engine and multi-process architecture. Since it averaged fewer processes than Chrome, Edge, and Opera, it seems that each of the processes was likely consuming more memory. It also had extremely consistent results, suggesting Firefox was keeping more of the workload actively loaded in memory rather than suspending or discarding it.

RAM alone still does not decide which browser I would use

Chrome lost the meme, but Brave did not automatically win everything

My opinion is that unless I’m using a PC with 4GB of RAM, using more of it doesn’t necessarily mean a browser is bad. That’s because browsers that retain tabs and cache data in memory often feel faster. I’m also of the opinion that if a computer has spare memory, I might as well use it.

My test covered a 10-tab workload on a fresh 8GB Windows 11 VM. Different setups involving logged-in accounts, popular browser extensions, and video streaming could easily change the results. But that doesn’t make my results meaningless. It just made them more standardized.

And while the benchmark can’t ultimately prove Firefox will always consume the most memory, it does show Chrome’s reputation can probably be put to bed. It’s also worth mentioning that there are browsers dedicated to low RAM usage, especially for older PCs:

• Pale Moon is based on Firefox and is focused on efficiency and more traditional desktop browsing.
• Falkon is a Windows and Linux browser that’s lightweight and community-supported.
• UR browser is a Chromium-based and privacy-focused browser with VPN support.
• Thorium is a recompiled Chromium-based browser that’s aggressively optimized and tweaked for low memory usage.

I intentionally didn’t include these browsers because they’re already tried and tested, and because I wanted to compare mainstream browsers with high market share.

I will still choose browsers based on privacy, compatibility, and features rather than just RAM usage alone. However, the next time someone posts the Chrome memory meme, I now have 450 samples per browser that definitely prove otherwise.