Ad Blocker Rule Count and Chrome CPU: What 195K Rules Do (2026)

You reopen the tab and the CPU meter climbs again. Your ad blocker is running, but its rule count is low, so the trackers it misses still load. The renderer parses their scripts and runs them. That spend is what the meter shows, and it is the time that delays the page you actually care about.

Key takeaways

• A larger ad-blocker rule set stops more third-party requests before they reach the network, so the tab’s renderer never parses or runs their scripts.
• Chrome guarantees at least 30,000 static rules per extension. Rules above that draw from a global pool shared across every installed extension.
• Rule matching has its own small overhead, so more is not free, and the extension details page never shows your rule count.

The short answer

Answer: Yes, within limits. A larger rule set stops more third-party requests before they reach the network, so the tab’s renderer never parses or executes their scripts. The rules are evaluated natively by Chrome’s engine, which adds a small matching cost per request instead of per-page JavaScript.

To see this on your own machine, do two things:

1. Open the extension’s details at chrome://extensions. It lists the name, version, and description, but not a rule count.
2. Open DevTools with Ctrl+Shift+I (Windows and Linux) or Cmd+Option+I (Mac), switch to the Performance panel, and record a page load. Long tasks on the main thread get a red-triangle flag, and an unblocked tracker script’s main-thread work can show up the same way.

Why rule count decides CPU

The number that matters is not the raw rule total, but how many of the third-party requests on a page a rule set actually catches. Each ad unit on a typical page brings its own iframe process, a render-blocking script, and an image payload. When a declarative rule catches that request before it hits the network, none of that weight enters the download queue. The renderer never parses the script and never executes it, so the main-thread work you flag as long tasks simply does not happen.

That is where the rule count becomes the variable. A thin set misses more requests, so more of that weight reaches the renderer and burns CPU on a tab that looks idle. A fuller set stops more of it upstream. The matching cost itself is small and bounded: Chrome evaluates declarative rules natively, checks at most one candidate rule per extension per request, and breaks ties by priority and then action order. That is a small cost, not a per-page script that re-runs on every load.

Two things keep it from being “more is always faster.” First, Chrome notes that loading and evaluating rules carries its own performance overhead, so a rule set has a real cost to maintain. Second, the count is capped by the browser, which is the next section.

Every current ad blocker runs on these declarative rules. Chrome removed MV2 webRequest blocking in Chrome 139 and disabled MV2 extensions in July 2025, so a blocker’s declarative rule set is now what it uses to stop network requests.

The limits Chrome enforces

Chrome does not let an extension load an unbounded rule set. Per extension it can declare up to 100 static rulesets, enable at most 50 at once, and it guarantees room for at least 30,000 static rules. Rules beyond that guarantee draw from a global pool shared across every installed extension, and the remaining headroom can be read at runtime.

One behavior worth knowing: since Chrome 128, disabling an extension at chrome://extensions frees its static rules from the global pool, and re-enabling it can leave fewer rules available than before. A heavy block can quietly take headroom away from another extension’s rules.

Reading what the check shows

The check in the first section points you at two surfaces, and each has a limit you should understand.

The extension details page shows the name, version, and description. It does not display a DNR rule count, so there is no interface readout for how many rules your blocker actually ships. The only documented runtime check for rule headroom is the getAvailableStaticRuleCount() API, which a developer can call. It reports how much of the pool is still free, not how many rules a specific blocker carries.

The Performance panel tells you the consequence, not the count. The long tasks it flags are renderer main-thread work. A fuller rule set removes some of that work by stopping requests before the network. So a higher count is not automatically a faster tab: it trades a small matching overhead against fewer requests to parse and run. The read is whether the requests you care about keeping are the ones that load, and the trackers are the ones that do not.

What a full block changes

If your current blocker ships a small rule set, the upgrade is a block that stops more requests before they reach the network. SuperchargePerformance ships 195,123 declarative rules across 15 rule files, all running within Chrome’s MV3 limits as of its live 1.5.1 build. Its blocking tiers run from Off through Low, Med, and High, and none of them require a paid plan. A full block keeps its 34 protected web-app domains (mail, docs, sign-in) working while it stops the rest, so the renderer never parses or runs the scripts a thin set would have let through.

If your blocker’s rule set is thin and your tabs sit open for a long time, a full-tier block is a steady efficiency win rather than a fix to a fire. If your traffic is light and you keep few tabs open, Chrome’s own defaults plus a modest block may already be enough.