TL;DR
Brave rebuilt its Rust adblock engine using FlatBuffers and other refinements, cutting memory use by about 75%—roughly 45 MB per browser instance by default. The changes are available in Brave v1.85, with further optimizations planned for v1.86.
What happened
Brave's engineering teams reworked the browser's Rust-based adblock engine, migrating its default filter set into a compact FlatBuffers layout. By moving roughly 100,000 shipped filters out of conventional heap-allocated Rust structures (Vecs, HashMaps and structs) into a zero-copy binary format, the team reduced memory consumed by the engine by three quarters. The update is included in Brave v1.85 and demonstrates a memory drop in internal comparisons (for example, from 162 MB to 104 MB between earlier and current builds). Additional improvements made during the project include using stack-allocated vectors to cut allocations and speed builds, tokenizing common regexes to accelerate matching, sharing resources between engine instances to save a couple of megabytes on desktop, and optimizing internal storage for further reductions. Some of these refinements are already live and others are slated for v1.86.
Why it matters
- Lower per-process memory reduces pressure on mobile devices and older machines, potentially improving multitasking and responsiveness.
- Smaller in-memory footprint can translate to less background resource use for each browser instance, benefiting battery-constrained devices.
- Because Brave’s adblocking is built into the browser, the team could apply low-level, cross-platform optimizations not possible for extension-based blockers.
- Reductions scale with additional filter lists, so users who enable extra lists may see larger savings.
Key facts
- Brave reports a 75% reduction in memory consumption for its Rust adblock engine.
- The change equates to about 45+ MB saved per browser instance by default, across Android, iOS and desktop.
- The overhaul uses FlatBuffers to store roughly 100,000 default adblock filters in a zero-copy binary format.
- Updates are live in Brave v1.85; more optimizations are planned for v1.86.
- A screenshot comparison cited in Brave shows memory dropping from 162 MB to 104 MB between older and newer builds.
- Stack-allocated vectors reduced memory allocations by 19% and improved build time by ~15%.
- Tokenizing common regex patterns boosted filter matching speed by about 13%.
- Sharing resources between adblock engine instances saves ~2 MB on desktop, and internal storage was optimized by 30%.
- Brave’s adblocking engine is maintained in-house by its privacy team and is claimed to be unaffected by Manifest V3 limits on extensions.
What to watch next
- Rollout and user telemetry after v1.86 to confirm additional optimizations materialize as expected.
- Memory impact for users who enable multiple or third-party filter lists, since Brave says savings scale with extra lists.
- Real-world battery-life improvements and measurable multitasking gains: not confirmed in the source.
- Whether browser extension makers or browser vendors introduce API changes that enable similar low-level optimizations for extension-based blockers: not confirmed in the source.
Quick glossary
- FlatBuffers: A compact, binary serialization format designed for efficient reading without unpacking or allocating intermediate objects.
- Zero-copy: A technique where data can be read or used directly from its stored representation without copying it into separate in-memory structures.
- Manifest V3 (MV3): A revision of browser extension APIs that changes how extensions operate and access certain capabilities; it has implications for some adblocker extensions.
- Vec / HashMap: Common Rust data structures: Vec is a growable array, and HashMap is a key-value store; both typically allocate memory on the heap.
- Tokenization (in matching): Breaking patterns such as regular expressions into simpler components to speed up matching operations.
Reader FAQ
How much memory does the adblock engine save?
Brave reports a 75% reduction, roughly 45+ MB saved per browser instance by default.
Which Brave version includes this change?
The overhaul is included in Brave v1.85, with additional optimizations planned for v1.86.
Does this affect extension-based adblockers?
Brave says deep, low-level optimizations are not possible for extension-based blockers due to extension API and sandboxing limits; Brave's built-in engine is maintained separately and is claimed to be unaffected by Manifest V3.
Will this noticeably improve battery life?
Brave states the overhaul brings better battery life, but specific, measured battery improvements are not confirmed in the source.
Brave overhauls adblock engine, cutting its memory consumption by 75% PUBLISHED JAN 5, 2026 Share on X (formerly Twitter) Share on Reddit Share on Telegram Share on LinkedIn Privacy updates…
Sources
- Brave overhauled its Rust adblock engine with FlatBuffers, cutting memory 75%
- By blocking ads and trackers, Brave already reduces how …
- [Perf] adblock 0.11.0 perf issues #50463
- Hacker News
Related posts
- Why Refactoring Should Be Done In-Flow, Not As Backlog Stories
- iPadOS 26 Brings Apple Journal to iPad – A Daily Writing Companion
- Refactoring — Why It Shouldn’t Be Put on the Backlog as a Story