Network-Level Blocking, and Its One Limit
Network-level blocking cancels the request that would fetch an advert, so its bytes never load. That saves data and time. What it cannot do is remove the empty space the advert would have filled, because that is a job for CSS, not the network.
Why it matters
An advert is fetched by a network request. That request travels from your browser to the ad network's server. Network-level blocking stops that request before it leaves your computer. The advert never downloads. You save the bandwidth. The page loads faster.
But the page's HTML has already decided to reserve space for that advert. A 300-by-250 pixel box, say. When the advert doesn't arrive, the box sits empty. Network blocking can't fix that. That's not a network problem. That's a design problem that CSS would need to solve.
This trade-off shapes what Scalpel is: network-level blocking gives you speed and privacy gains, but not a perfectly tidy page. Scalpel v1 makes that trade-off deliberately.
How it works
When you load a page, the browser parses the HTML and starts fetching resources. The HTML might say: "Put an advert here. To get it, fetch from ads.adnetwork.com/banner.js."
The browser is about to make that request. Before it does, Chrome checks the request against the ad blocker's rules. The rule says: "Any request to ads.adnetwork.com, block it."
Chrome cancels the request. It never gets sent. The server never knows it happened. The advert bytes never travel to your browser. The network transaction is complete: it didn't happen.
The page still renders. The HTML still has the code that would have displayed the advert. But without the advert file, the JavaScript can't run, or the image can't display. The space sits empty.
That empty space is where network-level blocking hits its limit. The HTML has already laid out space for the advert. CSS is what controls that layout. CSS can hide elements or collapse empty space. But the browser rendered the page based on the original HTML, and that rendering is done.
Cosmetic filtering (hiding elements with CSS rules) could clean this up. But it requires the blocker to run JavaScript in the page, which requires access to the page's contents. Scalpel v1 avoids that. It stays at the network layer, where it doesn't need page access.
What does not matter
A page won't typically break because an advert request was blocked. Adverts are peripheral content. They're not core to the page's function. A news article doesn't need the advert sidebar to display the text. A product page doesn't need banner ads to show the product details.
There are exceptions. Some sites have JavaScript that, if an advert script doesn't load, throws an error that cascades and breaks the page. Some sites use advert placement as a revenue trigger. If the advert isn't there, parts of the page don't render. These cases are rare. Most pages work fine without their adverts.
If a page does break, you can allowlist it from Scalpel's right-click menu. That site's requests go through unblocked. The page loads fully. You trade privacy for functionality, and you're in control of that trade-off.
The visual clutter of empty ad spaces is a cosmetic problem. Network-level blocking solves the privacy and speed problem. If you want to solve the cosmetic problem too, you'd need an ad blocker that uses cosmetic filtering. Scalpel might add that in a future version as an optional, opt-in layer.
Code example
Suppose a site has this HTML:
<div class="ad-container">
<script src="https://ads.example.com/banner-loader.js"></script>
</div>
<article>
<h1>Article Title</h1>
<p>Article content here...</p>
</article>
The page is structured: an ad container, then the article. When Scalpel blocks the request to ads.example.com/banner-loader.js, the <div class="ad-container"> is still there in the DOM. It's still part of the page layout. It's just empty.
In the browser, it looks like:
[empty ad space]
Article Title
Article content here...
If the site wanted to clean this up, it could use CSS:
.ad-container {
display: none; /* Hide the div entirely */
}
But Scalpel can't inject that CSS without running code in the page. So Scalpel leaves the empty space as-is. The advert is blocked. The data is saved. The tracking is stopped. The box is empty.
How Scalpel Ads Blocker shows it
Scalpel blocks at the network layer only. Its ruleset consists entirely of request-blocking rules. When you load a page, Scalpel counts how many requests were blocked, and it shows that number in the badge.
If you see an empty ad space on a page, that's what network-level blocking looks like. The advert bytes didn't download. The tracking request didn't happen. The bandwidth was saved. But the visual gap remains because Scalpel doesn't inject CSS rules to hide empty elements.
If the empty space bothers you and the page still works, you don't need to do anything. If the page broke because of missing adverts, you can allowlist the site from the right-click menu.
In future versions, Scalpel might offer cosmetic filtering as an optional layer. That would require a permission for page access, which is a privacy trade-off. For now, v1 keeps to network-level blocking, which keeps privacy high and permissions minimal.