What Is a Filter List?

## Why it matters

Ad blockers don't know what to block because they have an algorithm. They know because someone maintains a list. That list is a filter list: thousands of rules saying "this domain serves adverts" or "this URL is a tracker." The list gets updated constantly as new ad networks launch and old ones shut down.

Understanding filter lists matters because you can see exactly what Scalpel is blocking. It's not opaque. The rules are public, maintained by volunteers, and you can read them yourself if you want to know what gets stopped on a particular site.

## How it works

A filter list is a plain text file. Each line is a rule. The simplest rules look like this:

||ads.example.com^
||tracker.thirdparty.net/beacon
Copy

The first rule blocks anything from ads.example.com. The second blocks requests to a specific URL. Rules can be much more complex: targeting only certain resource types, only third-party requests, with exceptions for particular sites.

When you add options, the rule gets more specific:

||ads-cdn.example.com^$script,third-party
Copy

This blocks the domain but only for script requests that come from a different site than the one you're on.

Scalpel takes these text rules and converts them into Chrome's declarativeNetRequest JSON format at build time (once, when the extension is packaged). That conversion happens offline, before the extension ships. At runtime, Chrome reads the JSON rules directly and applies them without Scalpel having to translate anything. It's fast and does not need a network call.

## What does not matter

The exact syntax varies between different blockers. uBlock Origin uses a slightly different rule format than Adblock Plus. What matters for Scalpel is that the underlying logic is the same: list the patterns to block, Chrome stops matching requests. The syntax differences are an implementation detail.

Filter lists are not machine-learned. No AI is inferring what looks like an ad. Volunteers and volunteers' tools maintain the lists by hand, and what gets added is a human decision based on observation. That's why a blocklist stays honest. It's not trying to maximise blockage or second-guess; it's trying to block what actually is an ad or tracker.

A filter list does not customise blocking per user. Everyone using the same list blocks the same things. Your allowlist is the customisation layer: you decide which sites are exceptions for you.

## Code example

Here's what a few rules from EasyList look like in text format:

! Adblock Plus 2.0
! Homepage: https://easylist.to
! Licence: https://easylist.to/licence
! Last modified: [timestamp]
||pagead2.googlesyndication.com^
||ads.google.com^$third-party
||banner-ad.doubleclick.net^
||ad-provider.com/ads/display$script,domain=news.example.com
Copy

Scalpel bundles a snapshot of EasyList and converts it to declarativeNetRequest JSON at build time:

[
  {
    "id": 1,
    "priority": 1,
    "action": { "type": "block" },
    "condition": {
      "urlFilter": "||pagead2.googlesyndication.com^"
    }
  },
  {
    "id": 2,
    "priority": 1,
    "action": { "type": "block" },
    "condition": {
      "urlFilter": "||ads.google.com^",
      "domainType": "third-party"
    }
  }
]
Copy

This JSON is what Chrome actually runs. The conversion is one-way and happens once. At runtime, there's no parsing, no list-reading, just rule matching.

## How Scalpel Ads Blocker shows it

In the extension settings, you can see which filter lists are active. Scalpel ships with EasyList and EasyPrivacy turned on by default. You can toggle additional lists on or off if you want more or fewer blocks.

Each list shows how many rules it contains and when Scalpel's pinned snapshot was taken. Since the lists are bundled, not fetched live, you can see exactly what you're running and when it was last updated. No surprise list updates, no "check for updates" button. The list you have is the one that shipped with the extension.