ExtSherlock — Extension Doctor

Find out which VS Code extension is actually slowing you down — and fix it in one click.

Using GitHub-sourced badges rather than Marketplace badges, since the Marketplace ones only resolve once the extension is actually published there. Once AnandShah.extsherlock is live, you can add Marketplace version/install/rating badges back alongside these — see the commented note in this section for the snippet.

The problem

VS Code slows down. One of your extensions is probably responsible. Finding out which one usually means disabling everything and re-enabling extensions one by one, hoping you notice a difference — a slow, unreliable process most people never actually do.

What ExtSherlock does instead

ExtSherlock profiles the extension host with the same technology VS Code's own Developer: Start Extension Host Profile command uses internally, then turns the raw profile into a plain-language diagnosis: which extension, how much CPU/memory, why it matters, and what to do about it — with a one-click fix.

Screenshot / demo GIF goes here.

Features

🩺 Real diagnosis, not guesswork

Runs an actual V8 CPU + heap sampling profile of the extension host and attributes every sample back to the extension whose installed files it came from — the same underlying mechanism VS Code's own internal profiler uses. No polling top, no heuristics based on install size.

📊 A baseline you can trust

Every scan reports what share of CPU time went to your extensions collectively vs. VS Code's own core — so "this extension is 80% of the problem" is a measured ratio, not a vibe. Want a hard before/after number? Baseline A/B Comparison disables every other extension, reloads, scans again, and reports the real delta in CPU, lag, and memory.

⌨️ Typing-triggered vs. always-on background cost

Distinguishes extensions that only cost CPU while you're actively editing (usually a completion/linting/formatting provider — tune its trigger settings) from extensions burning CPU with the editor completely idle (usually a poller or watcher — just turn it off).

🔍 Root-cause bisection, not just a list

Quarantine mode disables every flagged extension at once. Confirm the problem's gone, and ExtSherlock walks you through re-enabling candidates one at a time — reload, "is it back?", repeat — until it identifies the actual culprit and restores everything else automatically.

⚔️ Conflict detection

Flags overlapping formatters, linters, git UI extensions, icon themes, language servers, and spell checkers — a common, easy-to-miss source of duplicated work and flaky behavior.

📈 Trends, not just a snapshot

Every scan is remembered. The impact table shows how each extension's cost has moved since your last few scans, and flags sharp jumps automatically ("GitLens: ~8% → 22% CPU").

🚀 Catches problems before you notice them

• Startup report — profiles the first ~10 seconds after VS Code becomes usable, catching heavy lazy-activation work.
• Auto-scan on install/update — a new or updated extension gets scanned within seconds, so a regression shows up immediately instead of days later.
• Lag-spike auto-scan — a sudden stutter triggers a scan automatically.

🔗 Community context

For flagged extensions with a public GitHub repo, ExtSherlock checks for open performance-related issues and surfaces "3 others have reported this" with a link — so you know if it's a known problem before you file a duplicate.

🧭 Always-visible status

A small, persistent status bar item shows live CPU% and input lag without needing the panel open, turning yellow/red exactly when the vitals strip would.

📤 Shareable reports

Export any diagnosis as Markdown (ready to paste into a bug report) or JSON (full structured data), complete with the profiling numbers to back it up.

Quick start

1. Install ExtSherlock and open the ExtSherlock icon in the Activity Bar.
2. Click Run Deep Scan (or just wait — a startup scan runs automatically).
3. Read the Diagnosis section. Each finding has a Disable in this workspace button.
4. Not sure which of several flagged extensions is the real cause? Click Quarantine Flagged (bisect) and follow the prompts.

No configuration required. Every automatic behavior can be turned off in Settings if you'd rather run scans manually.

Commands

All commands are available from the Command Palette (Ctrl+Shift+P / Cmd+Shift+P):

Settings

How it works, briefly

All of your extensions run inside one shared Node.js process (the "extension host"). There's no public VS Code API that hands you clean per-extension CPU/RAM, so ExtSherlock uses Node's built-in profiling APIs to sample that process directly — the same mechanism behind VS Code's own Developer: Start Extension Host Profile — then matches each sampled call frame's source file back to the extension whose installed folder it lives in.

A few honest caveats, in plain terms:

• It's a sample, not perfect accounting. Longer scans are more accurate; very short or bursty spikes can be under- or over-represented.
• Memory numbers are allocation volume during the scan, not "current RAM owned by extension X" — the extension host's heap is shared, and VS Code doesn't expose true per-extension retained memory.
• The startup report starts at "VS Code is usable," not at process launch. Measuring earlier would require ExtSherlock itself to eagerly load on every launch — exactly the kind of startup cost this extension exists to catch.
• The typing-vs-background split is a time correlation, not a causal trace: it can't prove an extension's code ran because of your keystroke, only that the two happened close together.

None of this makes the numbers untrustworthy — it's the same category of data VS Code's own internal tooling relies on — but treat percentages as directional evidence, not a certified audit.

Privacy & network access

ExtSherlock reads and profiles data entirely on your machine, with one exception: when an extension is flagged and its package.json declares a public GitHub repository, ExtSherlock queries GitHub's public Search API (api.github.com) for open issues mentioning "performance" in that repo. Results are cached locally for 24 hours and lookups are capped per scan to respect GitHub's rate limits. No other data leaves your machine, and this can be turned off entirely with extsherlock.communityCorrelationEnabled: false.

Requirements

• VS Code 1.85.0 or later.
• No other dependencies — ExtSherlock ships as a single bundled extension.

Known limitations

• Profiling briefly adds its own small CPU overhead during a scan (this is itself measured and shown as "VS Code core" in the baseline split, not hidden).
• The Baseline A/B comparison and Quarantine mode both rely on workbench.action.reloadWindow, so unsaved editor state should be saved first — VS Code will restore open files, but it's good practice regardless.
• Community issue correlation only works for extensions with a public GitHub repository field and is best-effort (rate-limited, no auth token).

FAQ

Does ExtSherlock slow down VS Code itself? Background vitals sampling is lightweight (a timer read every couple of seconds). Deep Scans do add measurable CPU load for their duration (default 8–10s) — that's the cost of getting a real profile rather than a guess.

Will disabling an extension lose my settings? No — disabling (workspace or global) never uninstalls anything. Re-enable any time from the Extensions view or ExtSherlock's own "Restore Extensions".

Can I use this without ever running a Deep Scan? Yes — the vitals strip and status bar work from lightweight background sampling alone. Deep Scan (and the per-extension diagnosis it enables) is opt-in, though a short startup scan runs automatically by default.

Contributing

Issues and pull requests are welcome. See DEVELOPMENT.md for the project layout, local dev setup, and implementation notes, or open an issue at github.com/AnandShah10/extSherlock/issues.

Release notes

See CHANGELOG.md.

License

MIT