I’ll be honest—I didn’t think I needed a spell checker in VS Code until I pushed a commit with “recieved” in a variable name. My team noticed. I learned my lesson.
If you’re coding in a browser-based VS Code environment—whether it’s GitHub Codespaces, Gitpod, or the vscode.dev web client—you’ve probably run into the same problem. Desktop extensions don’t always work the same way in the cloud. And spell checkers? They’re surprisingly tricky to get right when you’re working with code, not prose.
So let’s talk about what actually works when you need to catch typos in code without sacrificing privacy, performance, or your sanity.
Why Browser-Based VS Code Changes the Game
Here’s the thing about web environments: they’re sandboxed. That means extensions can’t always access your local file system or run background processes the same way they would on desktop. Traditional spell checkers rely on dictionaries stored locally, but in the cloud, you’re often stuck with whatever the extension author baked in.
Plus, there’s the privacy angle. When you’re coding on someone else’s machine—or in a browser tab that could theoretically be monitored—you probably don’t want your spelling suggestions bouncing through some third-party server. A good spell checker for VS Code web environments should handle everything client-side.
I’ve tested half a dozen options, and here are the ones that actually deliver.
The Top Contenders for Code-Aware Spell Checking
1. Code Spell Checker (by Street Side Software)
This is the one I keep coming back to. It’s open source, works entirely offline, and understands that “const” and “typeof” aren’t misspellings. The extension ships with a solid English dictionary, but you can add custom words, ignore specific file types, and even set up per-project dictionaries.
What makes it shine in web environments? It doesn’t phone home. No data leaves your browser. And it’s lightweight—no noticeable lag, even in larger projects.
The catch? Grammar support is basic. It’ll flag “teh” but won’t tell you if your sentence structure is awkward. If you need more than spelling, you’ll want something else alongside it.
2. LTeX – LanguageTool for VS Code
If grammar matters as much as spelling, LTeX is worth a look. It uses LanguageTool under the hood, which means it catches style issues, passive voice, and even some readability problems. It supports multiple languages—Spanish, French, German, you name it.
In a web environment, LTeX runs as a local server inside your browser. That means it’s still private, but it does use more resources. I’ve noticed some lag in larger files, especially on slower machines. Still, if you’re writing documentation, comments, or commit messages that need to sound professional, it’s hard to beat.
The downside? It’s not as code-aware as Code Spell Checker. You’ll get false positives on variable names and function calls. You’ll need to configure it to ignore certain patterns.
3. GitHub Copilot’s Built-In Spell Checker
If you’re using GitHub Codespaces, you might already have this one. Copilot includes a basic spell checker that highlights typos in comments and strings. It’s not as configurable as the others, but it’s zero-effort—no installation, no setup.
The catch is that it’s tied to Copilot. If you’re not paying for that, you won’t get the feature. And it’s not available in other web environments like Gitpod.
What About Grammar and Multilingual Support?
Here’s where things get interesting. Most spell checkers for code environments treat grammar like an afterthought. They’ll catch “their” vs “there” in comments, but they won’t help you write clearer documentation or avoid awkward phrasing in your README.
If you’re writing in multiple languages—say, English code comments with Japanese variable names—you need something that handles both without breaking. Code Spell Checker supports multiple dictionaries, but you have to install each one separately. LTeX handles multiple languages more gracefully, but again, it’s heavier.
For a balanced approach, I pair Code Spell Checker with a separate grammar tool. Something like the BeLikeNative platform works great for polishing documentation, commit messages, or even inline comments before you push. It’s not an extension, but it fills the grammar gap nicely.
Privacy Considerations You Can’t Ignore
Let me be blunt: not all spell checkers are created equal when it comes to privacy. Some rely on cloud APIs to process text. That’s fine for personal projects, but if you’re working on proprietary code, you probably don’t want your variable names floating around on someone else’s server.
The safest bet is to stick with extensions that run entirely locally. Code Spell Checker and LTeX (in its local mode) are both good choices. Avoid anything that requires an API key or sends data to an external service unless you’re absolutely sure about their data handling.
If you’re curious about the best options for your specific setup, I wrote a detailed comparison on the Best Spell Checker For VS Code Web Environments page that breaks down each tool’s privacy policies and performance benchmarks.
Practical Tips for Setting Up Your Spell Checker
Here’s how I configure mine for maximum usefulness without driving myself crazy:
-
Start with Code Spell Checker. Install it, then add your project’s custom words (like library names or abbreviations) to a
.cspell.jsonfile. This keeps your dictionary consistent across your team. -
Add a grammar checker for documentation. Use something like the text simplifier tool on BeLikeNative to clean up README files and inline comments. It catches the stuff spell checkers miss—like run-on sentences or overly complex phrasing.
-
Configure file exclusions. Don’t let your spell checker scan
node_modules,dist, or generated files. It’ll slow you down and flag nonsense. Most extensions let you set glob patterns to ignore. -
Enable multi-language support if needed. If your project mixes English and another language, install the corresponding dictionary and set the language toggle in your settings.
-
Test in a web environment first. Not all extensions behave the same in Codespaces vs vscode.dev. I learned that the hard way when an extension that worked flawlessly on desktop just refused to load in the browser.
The Verdict
For most people, Code Spell Checker is the best starting point. It’s free, private, and works in every web-based VS Code environment I’ve tested. Pair it with a grammar tool for documentation, and you’re covered.
If you need multilingual support or heavy grammar checking, LTeX is the better choice—just be prepared for a slightly heavier resource footprint.
And if you’re in GitHub Codespaces and already paying for Copilot, try the built-in checker first. It might be enough.
The key is to find something that fits your workflow without adding friction. A spell checker that slows you down or gives too many false positives isn’t worth installing. But one that catches the occasional typo before it hits production? That’s gold.
FAQ
Can I use desktop VS Code extensions in browser-based VS Code?
Not always. Some extensions rely on native binaries or local file access that isn’t available in web environments. Always check the extension’s documentation for web support before installing.
Do these spell checkers slow down my editor?
Code Spell Checker is lightweight—I’ve never noticed lag. LTeX can be heavier, especially on large files. If performance is a concern, stick with the simpler option.
How do I add custom words to my spell checker?
Most extensions let you create a dictionary file (like .cspell.json) in your project root. You can also use the command palette to add words on the fly. This keeps your custom terms synced across your team.