You know that moment. You open a large Rust workspace in VS Code, and rust-analyzer starts spinning. Your fans spin up. Your laptop gets warm. You wait. And wait. And then you check your memory usage and see 2GB gone—just so your editor can show you a syntax error you already spotted with your eyes.
That pain? It’s not a bug. It’s a design choice. And a new tool called Rust Glancer is proving that choice was wrong.
Here’s the uncomfortable truth: your IDE doesn’t need to know everything about your code to be useful. Rust Glancer, built by the developer behind the original rust-analyzer prototype, takes a radical bet: throw away 90% of the data and still handle 90% of the use cases. The result? An LSP that uses 100x less RAM—and feels instant.
Let’s be honest: most of what a traditional LSP does is overkill. Full in-memory abstract syntax trees, type inference for every single expression, compilation unit resolution for the entire workspace. You don’t need that to auto-complete a method name or highlight a type mismatch. You need it for deep refactoring and cross-crate analysis—which happens maybe 10% of the time.
The 90% use case isn’t a compromise—it’s a design revelation. Rust Glancer treats the heavyweight analysis as a separate, on-demand concern. It guesses, it approximates, it uses a lightweight index. And it’s honest about what it can’t do. That’s refreshing in a world where every tool promises to be everything.
I’ve spent years in large Rust codebases. I’ve watched engineers switch to smaller editors, disable LSPs, or just live with the lag. We’ve been gaslit into believing that the only way to have good IDE support is to build a full compiler in your editor. Rust Glancer says: no, we can have a fast, good-enough experience 90% of the time, and then summon the heavy artillery when we actually need it.
One commenter captured it perfectly: “I’d just assumed that was the only way.” That’s the trap. We assume the heavyweight approach is necessary because it’s the only one we’ve seen. But sometimes the best innovation is deciding what to not do.
Your editor doesn’t need to be a compiler. It needs to be a good assistant. Rust Glancer is a wake-up call for the entire tooling ecosystem. It’s not a toy—it’s a principled challenge to the status quo. And the fact that it works means the rest of us have been overpaying for memory we didn’t need.
So next time you see rust-analyzer eating a gigabyte, ask yourself: is that complexity actually making me faster? Or is it just making my laptop slower?
FAQ
Q: But what about the missing 10% of features—won't that break my workflow?
A: The missing 10% are exactly the cases where you need deep refactoring or cross-crate type inference. Rust Glancer's design is to handle those as separate, slower processes that you invoke only when needed. For the 90% of everyday coding—autocomplete, diagnostics, simple navigation—it's more than enough.
Q: How does this affect my daily workflow as a Rust developer?
A: If you work on large workspaces, you'll see instant startup and snappy responses with zero memory pressure. You'll lose some deep IDE features, but you gain the ability to work without your laptop turning into a space heater. The trade-off is worth it for most daily tasks.
Q: Isn't this just a compromise? Why not have both—fast and full-featured?
A: That's the ideal, but physics and engineering trade-offs exist. A full compiler-backed LSP will always be memory-heavy. Rust Glancer's bet is that the 10% of heavy features are better served by a separate tool, not jammed into the editor. It's a pragmatic separation of concerns, not a compromise.