By ByteBot
Brave browser cut adblock memory usage by 75% in January 2026, saving 45 MB across Android, iOS, and desktop. The improvement ships in Brave v1.85 through a FlatBuffers rewrite of their Rust adblock engine, transitioning 100,000 filters from heap-allocated data structures to zero-copy binary format. While Microsoft ships AI features that make VSCode slower and buggier, Brave’s engineering team delivered measurable performance gains users feel: better battery life, smoother multitasking, and proof that “rewrite it in Rust” works when backed by smart architecture.
From Heap Allocation to Zero-Copy FlatBuffers
Brave moved 100,000 adblock filters from standard Rust data structures to FlatBuffers’ zero-copy binary format. Before: Vecs, HashMaps, and structs allocated on the heap. After: direct buffer access with no copying, no parsing. The result: 162 MB dropped to 104 MB between v1.79.118 and v1.85.118—a 75% memory reduction live in production.
The optimization wasn’t a single silver bullet. Brave compounded multiple improvements. Stack-allocated vectors reduced allocations by 19% and build time by 15%. Regex tokenization sped up filter matching by 13%. Resource sharing between engine instances saved ~2 MB on desktop. Internal resource storage became 30% more efficient. Add them up: 75% total memory reduction from layered engineering.
FlatBuffers enables zero-copy deserialization—you access serialized data without copying it to separate memory. For 100,000 filters checked on every web request, this compounds massively. Traditional approaches parse JSON, allocate structs, copy data. FlatBuffers reads the binary buffer directly. Instant access, no overhead.
Why 45 MB Actually Matters
Skeptics on Hacker News noted 45 MB is only 0.5% of 8 GB RAM on modern smartphones. True, but that’s not how memory pressure works. Cache efficiency matters more than raw percentages. Ten browser tabs multiply the savings to 450 MB freed for other apps. Battery impact isn’t linear—less memory pressure means less swap, less CPU overhead, longer battery life.
Mobile users benefit most. Smartphones have limited RAM and battery-critical workloads. Older devices with 4-8 GB RAM feel the difference immediately. Even on high-end hardware, 45 MB per instance means less fan noise, smoother performance, and less thermal throttling.
One Hacker News commenter got it right: “45 MB per instance times millions of users equals Brave just saved more memory than most apps will ever use.” Performance engineering at scale multiplies impact. Brave delivered that.
Brave Optimizes While Competitors Add Bloat
Brave’s 75% memory reduction lands the same week Microsoft faces developer backlash over VSCode AI bloat. On January 6, 2026, ByteIota covered how VSCode ships AI features faster than users can disable them, causing “slower, buggier” performance. Developers are abandoning VSCode’s 40,000 extensions for Zed’s native speed because Microsoft prioritizes feature velocity over stability.
Brave chose the opposite path. Remove bloat, optimize performance, ship improvements users feel. The industry trend favors “more features equals better” even when performance degrades. Brave proves performance itself is a feature—one users notice enough to switch browsers for.
Microsoft ships AI features faster than performance fixes. Brave does the opposite. Developers vote with their tools, and performance-first engineering wins.
Rewrite It in Rust Actually Worked
“Rewrite it in Rust” is a developer meme, often dismissed as cargo cult thinking or hype over substance. Brave validated it with hard numbers. Their Rust journey started in 2019-2020 when they rewrote their C++ adblocker in Rust, delivering a 69x speed improvement down to 5.7 microseconds per request. Now in 2026, FlatBuffers optimization cuts memory 75%. The adblock engine is both faster AND leaner than alternatives.
Honesty matters here: Rust alone didn’t deliver this. Smart architecture did—FlatBuffers, tokenization, stack allocation. But Rust enabled the optimization through zero-copy support, memory safety guarantees, and the crates ecosystem. The adblock-rust repository has 28 contributors, 605 dependent projects, and publishes on crates.io for reuse. It uses Servo crates shared with Firefox, proving open source collaboration works.
Brave proved Rust rewrites succeed when you combine the language with disciplined engineering. That’s not hype. That’s receipts.
Lessons for Developers
Performance engineering comes from architectural choices, not just language choice. Brave’s 75% memory reduction teaches four lessons.
First, use zero-copy data structures for serialization-heavy workloads. FlatBuffers shines when processing 100,000 filters per page load. Traditional parsing wastes CPU and memory; direct buffer access eliminates that overhead.
Second, compound optimizations multiply impact. Stack-allocated vectors (19% savings), regex tokenization (13% faster matching), and storage efficiency (30% improvement) combine to 75% total reduction. Look for multiple small wins, not one magic fix.
Third, performance is a feature users notice. VSCode users switched to Zed for speed. Chrome users switch to Brave for privacy and performance. When your competitors add bloat, you win by optimizing fundamentals.
Fourth, open source ecosystems enable collaboration. Rust crates like Servo components and crates.io distribution let Brave share engineering work across the industry. 605 projects now use adblock-rust. Performance improvements compound across the ecosystem.
Key Takeaways
- Brave cut adblock memory 75% (45 MB savings) via FlatBuffers zero-copy format, live in v1.85: Engineering milestone proving Rust rewrites deliver measurable gains when combined with smart architecture
- Battery life and multitasking improvements benefit mobile and older hardware most: Skeptics dismiss 45 MB as small, but cache efficiency, tab multiplication, and battery impact make it significant at scale
- Performance-first engineering contrasts with VSCode AI bloat trend: While Microsoft degrades UX with forced features, Brave optimizes fundamentals—developers notice and switch tools
- Compound optimizations (19% + 13% + 30%) delivered 75% total reduction: Stack allocation, regex tokenization, and storage efficiency layered together prove multiple small wins beat single silver bullets
- “Rewrite it in Rust” validated with 69x speed + 75% memory improvements: Combining Rust’s capabilities (zero-copy, memory safety, ecosystem) with disciplined engineering (FlatBuffers, tokenization) delivers real performance, not hype
