Start with VS Code’s built-in Developer: Show Running Extensions command. It opens the Running Extensions editor, which is the correct first place to inspect extension activity. Because the exact columns and resource metrics can vary by VS Code build, treat it as an investigation view rather than assuming it provides a complete CPU-and-memory leaderboard. Then use an Empty Profile to test whether extensions or modified settings are involved, and use the command-line interface to create a repeatable inventory of installed extensions and versions.
What you can—and cannot—measure in VS Code
VS Code does not give every installation a guaranteed, version-independent ranking of extensions by CPU time and memory. Microsoft’s documentation confirms the Running Extensions editor and the commands used to open it, but the documentation available for this procedure does not establish that every current build exposes the same per-extension CPU and memory columns, units, or sorting behavior.
As an Amazon Associate I earn from qualifying purchases.
That distinction matters. You can reliably use the built-in tools to:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
- See which extension components are running or have activated in the current window.
- Check whether a problem disappears when extensions and changed settings are removed from the test environment.
- List installed extension identifiers and, optionally, their versions.
- Determine whether the work is occurring on your local computer, in a web environment, or on a remote workspace host.
You cannot assume that a number shown in one build is a directly comparable, per-extension CPU or memory measurement in another build. Record the VS Code version and the fields your own Running Extensions editor actually displays before drawing a ranking.
#1 Best Overall
1. Open the Running Extensions editor
- Open the Command Palette with the keyboard shortcut assigned to it in your operating system, or use the Command Palette menu command.
- Type
Developer: Show Running Extensions. - Select that command to open the Running Extensions editor.
- Read the activity information presented in your build. If CPU or memory fields are present, note their labels, units, time period and sort order instead of treating them as universal VS Code fields.
The command and editor were documented by Microsoft in the September 2022 (version 1.72) release notes. That release note establishes the entry point, not the exact layout of a current installation. A missing column is therefore not evidence that an extension uses no resources; it means your build is not presenting that measurement in that view.
Make a useful first pass
Capture the state before changing anything. Note the workspace, whether a large project is open, the actions that make the slowdown visible, and the extension entries shown as active. If the editor exposes a sortable metric, sort it once and write down the field name and value. Avoid combining values taken from different workspaces or after unrelated extensions have activated, because activation changes the set of running components.
Use this view to identify candidates for testing, not to declare a culprit immediately. An extension can be active because another feature requested it, and a process that appears busy may be handling workspace work that is not represented by a simple extension name.
Free tools Windows power users keep installed
One-click scans. No signup required.
2. Establish an Empty Profile baseline
An Empty Profile is the strongest built-in isolation check. VS Code describes it as a profile that disables extensions and modified settings. It lets you reproduce the same operation with those variables removed, so you can separate an extension-related problem from one caused by a setting or by VS Code core.
- Open the Profiles editor from the profile menu in the VS Code window.
- Create a new profile and choose the Empty Profile option, or select an existing Empty Profile.
- Open the same workspace, using the same files and the same sequence of actions as in your normal profile.
- Repeat the symptom-producing action: for example, the edit, search, build trigger or navigation that made the window slow.
- Compare the behavior with your original profile, recording what changed rather than relying on memory.
If the issue remains in the Empty Profile, extensions are not the only plausible cause. Investigate the workspace, VS Code itself, the files being processed or the operating environment. If the issue disappears, the controlled comparison shows that extensions or modified settings are involved; it does not identify a single extension or provide a per-extension CPU figure.
3. Narrow the responsible extension without guessing
When the Empty Profile comparison points toward the normal profile, reintroduce extensions in controlled groups. This is a diagnostic strategy based on the isolation purpose of profiles, not a direct resource meter.
Rank #2
Use a small-group test
- Start from the Empty Profile or another profile with no extension changes carried over.
- Enable a small, documented group of extensions that you suspect could affect the symptom.
- Reopen the same workspace and perform the same action for the same period.
- Record whether the symptom returns and which entries appear in the Running Extensions editor.
- If the symptom returns, split that group and test each half. If it does not, add another group and repeat.
Splitting a failing group in half reduces the number of test cycles compared with toggling extensions in an arbitrary order. Keep the workspace, files, action sequence and observation period stable so that each comparison answers the same question.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Change one extension at a time for confirmation
Once a small group repeatedly reproduces the behavior, disable all but one member and repeat the test. A candidate is more credible when the symptom appears with that extension enabled and disappears when it is removed while the other conditions stay constant. This still does not prove that the extension is the sole source: extensions can interact, and a setting changed by an extension can alter later work.
Keep an evidence log
- VS Code version and profile name.
- Workspace or project used for the test.
- Extensions enabled for that run, including versions when available.
- The exact action used to trigger the slowdown.
- What the Running Extensions editor displayed.
- Whether the issue occurred in the Empty Profile, the normal profile, or both.
- Whether the work was local, web-based or remote.
This log prevents a common error: blaming the extension that was most visible after a slowdown even though a different extension activated earlier or the test ran on a different host.
4. Use the VS Code CLI for a repeatable inventory
The command-line interface can prepare controlled runs and document exactly what is installed. These options do not measure resource use per extension, but they make your tests reproducible and let you match a result to extension versions.
Disable all extensions for a comparison run
code --disable-extensionsThe --disable-extensions option disables all installed extensions for that launched instance. Use it as a command-line counterpart to an extension-free comparison. It is an all-or-nothing switch, so it cannot tell you which individual extension consumed CPU or memory.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →List installed extension identifiers
code --list-extensionsThis prints the identifiers of installed extensions. Save the output with the date and the workspace used for your test so that a later comparison is based on the same installation state.
Include extension versions
code --list-extensions --show-versionsThe --show-versions option adds version information to the extension inventory. Use that output when you repeat a test after an update; otherwise, you may attribute a changed result to a configuration change when the extension itself has changed.
What the CLI does not provide
None of these options is a per-extension CPU or memory profiler. The list commands identify what is installed, and the disable option creates a comparison condition. Resource measurements must come from the fields exposed by your Running Extensions editor or from process observation on the host where the extension is actually running.
5. Identify the host before reading operating-system usage
VS Code can use local, web and remote extension hosts. Placement depends on the extension’s capabilities, your configuration and where the extension is installed. Consequently, a high-usage process on your desktop may not be the process doing the expensive work for a remote workspace.
Local workspaces
For a local workspace, the extension host normally belongs to the same computer as the VS Code window. If you compare the Running Extensions editor with operating-system process usage, make sure the process you are observing corresponds to that local window and test.
Web-based VS Code
In a web deployment, extension execution and the visible editor are not necessarily located in the same place as a desktop installation. Treat browser-side activity and any server-side activity as separate observations, and do not transfer a desktop process interpretation to the web session.
Remote workspaces
With a remote workspace, an extension may run on the remote workspace host rather than on the local UI machine. Check where the extension is installed and which host the active component uses before interpreting CPU or memory shown by either system. A local process can look quiet while the remote host is under load, or the reverse can occur.
Host location is a separate diagnostic axis from extension identity. First establish where the work is happening; then associate the observed activity with the extension and test conditions for that host.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minute6. Compare the available diagnostic approaches
| Approach | Identifies a specific extension? | Measures CPU or memory directly? | Host scope |
|---|---|---|---|
| Developer: Show Running Extensions | Provides running-extension activity that can be used to select candidates; exact identification fields depend on the installed build. | Current per-extension fields, units and ranking behavior are not stated in the cited documentation; verify what your build displays. | The VS Code window’s active extension environment; confirm whether the work is local, web or remote. |
| Empty Profile comparison | No. It tests extensions and modified settings as a group. | No direct per-extension measurement. | The environment in which you reproduce the same workspace and action. |
code --disable-extensions |
No. It disables all installed extensions. | No direct measurement. | The launched VS Code instance. |
code --list-extensions and --show-versions |
Lists installed identifiers and versions, not active resource consumers. | No. | The installation from which the command is run. |
| Operating-system process observation | Only when you can reliably associate the observed host process with the VS Code session and extension activity. | Shows process-level usage, not an established per-extension ranking from the VS Code documentation cited here. | Whichever machine is being observed; remote setups require checking the workspace host separately. |
7. How to interpret CPU and memory observations
Do not confuse activation with high usage
An extension appearing in the Running Extensions editor means it is running or has activated in that environment. It does not, by itself, establish that the extension is the largest CPU or memory consumer. Use activation information to choose a controlled test, then compare the same action with that extension present and absent.
Separate a one-time spike from sustained load
Indexing, opening a large workspace or running a language service can create a short burst. A sustained slowdown requires a different observation from a brief startup spike. Record when the symptom starts, how long it lasts and whether it returns after the same action; do not rank extensions from a single moment unless the editor explicitly labels the value and measurement period.
Keep memory observations in context
Memory attributed to a host process can include work shared by multiple extensions or services. A process-level value is therefore evidence about that host process, not automatically proof of an individual extension’s allocation. The controlled profile and single-extension tests are what connect a process change to a candidate.
Use the same workload
A comparison is meaningful only when the workspace, files, settings, extension set and action are held constant. Changing all of them at once can make a lower number look like an extension improvement when the real difference is the project or operation.
8. A repeatable investigation workflow
Use this sequence when you need an answer you can defend or reproduce after an update.
- Describe the symptom. Write down the exact action that causes high CPU, sluggish input or memory growth, and whether it happens at startup or during a particular task.
- Record the environment. Capture the VS Code version, profile, workspace, local/web/remote arrangement and extension inventory. Generate the inventory with
code --list-extensions --show-versionswhen the CLI is available. - Inspect running activity. Open
Developer: Show Running Extensionsand record the fields your build exposes. Do not add a ranking column that the editor does not show. - Run the Empty Profile test. Repeat the workload with extensions and modified settings disabled by the Empty Profile.
- Classify the result. If the symptom persists, broaden the investigation beyond extensions. If it disappears, continue with controlled extension groups.
- Narrow candidates. Reintroduce groups, split a failing group, then confirm one extension at a time.
- Verify placement. For remote or web sessions, observe the host where the extension executes rather than only the local UI machine.
- Recheck after changes. Repeat the same workload after updating an extension, changing its settings or switching workspaces, and keep the old inventory for comparison.
9. Troubleshooting branches
The Running Extensions command is missing
Confirm that you entered the command name exactly as Developer: Show Running Extensions. The documented entry point comes from VS Code’s version 1.72 release notes, while current builds can change command presentation. If your build does not offer it, use the Empty Profile and CLI inventory workflow, and document that the running-editor view was unavailable.
The editor opens but shows no CPU or memory ranking
Do not infer a ranking from the order of entries. The available documentation does not establish a universal set of current columns. Record the activity information that is shown, then use controlled profile tests and host-level process observations to determine whether extensions as a group are involved.
The Empty Profile is also slow
Because the Empty Profile removes extensions and modified settings from the comparison, a symptom that remains points to causes outside that extension set. Recheck the workspace and workload, verify whether the problem is local or remote, and avoid assigning blame to an extension solely because it was active in the normal profile.
The problem disappears, but no single extension stands out
Use smaller groups and then one-at-a-time confirmation. The result may involve an interaction between extensions rather than one extension acting alone, so test the combination that reproduced the symptom as well as each member separately.
Local and remote observations disagree
Repeat the test on the host where the extension is installed and executes. Keep separate notes for the UI machine and workspace host; combining their process readings can reverse your conclusion about where the load originates.
10. Common mistakes to avoid
- Calling the Running Extensions editor a guaranteed profiler. Its command is established, but current per-extension CPU and memory fields are not established for every build.
- Treating “running” as “most expensive.” Activation status selects candidates; it is not a resource ranking.
- Changing several variables at once. A different workspace, profile, extension version and workload cannot reveal which change mattered.
- Using
--list-extensionsas a performance report. It is an inventory command. - Watching only the local machine in a remote setup. Extension work may be occurring on the workspace host.
- Comparing values without recording units or timing. A number without its field name, unit and observation period is not a reliable comparison.
- Assuming a short startup spike proves a persistent leak. Repeat the same workload and observe whether the behavior is sustained or reproducible.
What a defensible conclusion looks like
A careful report distinguishes what was observed from what was isolated. For example: “The slowdown reproduced in the normal profile, disappeared in an Empty Profile, returned when a particular extension group was enabled, and was confirmed with one extension enabled at a time on the remote workspace host.” That statement is stronger than “the extension with the highest number is the culprit,” especially when the installed VS Code build does not document a complete per-extension CPU and memory ranking.
Use Developer: Show Running Extensions as the entry point, profiles and controlled reintroduction to isolate cause, CLI options to preserve the installation state, and host-aware observation to interpret process usage correctly. This combination answers which extensions are involved without claiming precision that your VS Code version does not actually provide.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteQuick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
