How to Fix VS Code Extensions Not Working: The Complete 2026 Troubleshooting Guide

Every developer has been there. You install a must-have extension, restart VS Code, and… nothing. The command palette is empty, the extension doesn’t activate, or worse — VS Code starts throwing cryptic errors that make zero sense.

If you’re searching for how to fix VS Code extensions not working, you’re in the right place. After years of debugging extension issues across hundreds of developer machines, I’ve compiled every root cause and solution into this single guide. We’ll go from the obvious fixes (that still trip up senior devs) to the edge cases that require registry editing and deep process inspection.

Let’s get your tools back online.

Understanding Why VS Code Extensions Fail

Before we start fixing things, it helps to understand the architecture. VS Code extensions run in a separate Extension Host Process — a dedicated Node.js process that isolates extensions from the main UI thread. When an extension fails, it’s usually because one of these components breaks down:

• The extension host process crashed or hung
• The extension files are corrupted or incomplete
• There’s a version incompatibility between the extension, VS Code, or your runtime
• Permission issues block file access
• Conflicting extensions override or block each other
• Network proxies interfere with extension activation

According to the VS Code team’s own telemetry, roughly 60% of extension failures come from version mismatches and corrupted installs. Another 25% are permission-related. The remaining 15% are genuine bugs or edge cases.

Knowing this helps you prioritize. Let’s work through the solutions from most likely to least likely.

Step 1: Reload the Extension Host Process

This fixes about 30% of cases. When an extension seems installed but doesn’t do anything, the extension host may not have picked it up properly.

Method 1: Developer Reload

# From the command palette (Ctrl+Shift+P or Cmd+Shift+P)
Developer: Reload Window

This restarts the entire VS Code window, including the extension host. It’s faster than a full restart and preserves your workspace state.

Method 2: Restart the Extension Host Specifically

# Command palette
Developer: Restart Extension Host

This is more surgical — it only restarts the extension process without reloading your UI. Useful when you have a large workspace and don’t want to wait for the full reload.

Method 3: Check the Extension Host Logs

If reloading doesn’t help, check what the extension host is actually doing:

# Command palette
Developer: Show Logs... → Extension Host

Look for activation errors. A typical error looks like this:

[2026-01-15 10:23:45.123] [exthost] [error] Activating extension 'ms-python.python' failed due to an error:
[2026-01-15 10:23:45.124] [exthost] [error] Error: Cannot find module '/home/user/.vscode/extensions/ms-python-2024.0.1/out/client/extension.js'

This specific error tells you the extension files are missing — which leads us to the next step.

Step 2: Verify Extension Installation Integrity

Extensions can partially download or get corrupted during updates, especially on unstable connections or when VS Code crashes mid-update.

Check the Extensions Folder

The location depends on your OS:

# Windows
%USERPROFILE%\.vscode\extensions\

# macOS
~/.vscode/extensions/

# Linux
~/.vscode/extensions/

Each extension should have a folder named like {publisher}.{name}-{version}. For example:

ms-python.python-2024.0.1/
├── .vsixmanifest
├── extension/
│   ├── package.json
│   └── out/
│       └── client/
│           └── extension.js
├── package.json
└── README.md

Reinstall the Problematic Extension

If the folder is missing files or seems incomplete:

1. Note the exact extension ID (visible in the Extensions sidebar)
2. Uninstall the extension completely
3. Close VS Code
4. Manually delete the extension folder if it still exists
5. Restart VS Code and reinstall

# Example: Completely removing a broken Python extension on macOS/Linux
rm -rf ~/.vscode/extensions/ms-python.python-*

Install from VSIX as a Fallback

If the marketplace install keeps failing, download the VSIX directly from the VS Code Marketplace and install it manually:

# Command palette
Extensions: Install from VSIX...

Or from the command line:

code --install-extension /path/to/extension.vsix

This bypasses marketplace connectivity issues entirely.

Step 3: Resolve Version Incompatibilities

This is the most common cause for experienced developers who update frequently. VS Code updates its internal Extension API regularly, and extensions that haven’t been updated can break.

Check Your VS Code Version

code --version
# Output example:
# 1.95.0
# 2adb0eb29c84e4f2e84f37d7c52a8c8e1f0b2c4a
# x64

Check Extension Compatibility

In the Extensions sidebar, look for the gear icon next to each extension. If an extension is incompatible with your VS Code version, you’ll see a warning like:

Extension is not compatible with Code 1.95.0. Requires 1.90.0 or lower.

Pin to a Compatible VS Code Version

If you rely on an extension that hasn’t been updated for the latest VS Code:

# Install a specific VS Code version using the official archive
# On macOS:
brew install --cask https://raw.githubusercontent.com/Homebrew/homebrew-cask/master/versions/visual-studio-code@1.90.rb

Downgrade an Extension

Sometimes the latest extension version is the problem. You can install an older version:

1. Go to the extension’s marketplace page
2. Click “Version History”
3. Download the previous VSIX
4. Install it manually using Extensions: Install from VSIX...

To prevent auto-updates from breaking your setup:

// settings.json
{
  "extensions.autoUpdate": false,
  "extensions.autoCheckUpdates": false
}

Step 4: Disable Conflicting Extensions

Extensions can conflict when they provide the same language features or hook into the same VS Code APIs. Common conflict pairs include:

• Multiple Python formatters (Black, autopep8, Ruff)
• Multiple language servers for the same language
• Theme extensions that override UI elements
• Git extensions that manage the same repository state

Use Extension Bisect

VS Code has a built-in tool specifically for this — Extension Bisect. It uses binary search to find the problematic extension:

# Command palette
Developer: Restart Extension Host
# Then:
Help: Start Extension Bisect

VS Code will disable half your extensions, ask if the problem is resolved, and narrow down the culprit in log2(n) steps. For 32 extensions, that’s just 5 restarts.

Manually Isolate the Problem

If bisect doesn’t work (some conflicts only appear with specific combinations), try this approach:

# Disable all extensions from the command line
code --disable-extensions

# Then enable them one by one, testing after each

Common Known Conflicts (2026)

Step 5: Fix Permission Issues

Permission problems are especially common on Linux, WSL, and systems where VS Code was installed with sudo or moved between users.

Check Extension Folder Ownership

# The extensions folder must be owned by your user
ls -la ~/.vscode/extensions/

# Fix ownership if needed
sudo chown -R $USER:$USER ~/.vscode/extensions/

Fix File Permissions

# Ensure read/write access
chmod -R u+rwX ~/.vscode/extensions/

# On macOS, also check for quarantine attributes:
xattr -dr com.apple.quarantine ~/.vscode/extensions/

Windows Permission Issues

On Windows, the problem is often that the AppData folder has restricted permissions:

# Check current permissions
icacls "%USERPROFILE%\.vscode\extensions" 

# Grant full control to your user
icacls "%USERPROFILE%\.vscode\extensions" /grant "%USERNAME%:(OI)(CI)F" /T

Corporate Managed Environments

If you’re on a managed corporate machine, Group Policy might block extension installation. Check:

# Check if policies are applied
gpresult /r | findstr -i "vscode"

The relevant registry keys are:

HKEY_CURRENT_USER\Software\Policies\Microsoft\VSCode

If you see ExtensionInstallBlocklist or ExtensionInstallForceList policies, you’ll need to work with your IT team.

Step 6: Clear VS Code Cache and State

VS Code stores a lot of cached data that can become stale or corrupted, causing extensions to behave erratically.

Clear Cached Extension Data

# Close VS Code completely first!

# Windows
del /f /s /q "%APPDATA%\Code\Cache\*"
del /f /s /q "%APPDATA%\Code\CachedData\*"
del /f /s /q "%APPDATA%\Code\CachedExtensionVSIXs\*"

# macOS
rm -rf ~/Library/Application Support/Code/Cache/*
rm -rf ~/Library/Application Support/Code/CachedData/*
rm -rf ~/Library/Application Support/Code/CachedExtensionVSIXs/*

# Linux
rm -rf ~/.config/Code/Cache/*
rm -rf ~/.config/Code/CachedData/*
rm -rf ~/.config/Code/CachedExtensionVSIXs/*

Reset Extension Global State

Extensions store state in VS Code’s global storage. If this gets corrupted, the extension may fail silently:

# Check global storage
# Windows
%APPDATA%\Code\User\globalStorage\

# macOS/Linux
~/.config/Code/User/globalStorage/  # Linux
~/Library/Application Support/Code/User/globalStorage/  # macOS

To reset a specific extension’s state, delete its folder:

# Example: Reset Prettier's state
rm -rf ~/.config/Code/User/globalStorage/esbenp.prettier-vscode

Nuclear Option: Reset All Settings

If nothing else works, you can reset VS Code to factory defaults:

# Backup first!
cp ~/.config/Code/User/settings.json ~/settings.json.backup

# Remove all user data
# Linux
rm -rf ~/.config/Code/

# macOS
rm -rf ~/Library/Application\ Support/Code/

# Windows
rmdir /s /q "%APPDATA%\Code"

Warning: This removes all your settings, keybindings, and snippets. Only use this as a last resort.

Step 7: Diagnose Runtime and Environment Issues

Some extensions depend on external runtimes. If those runtimes are missing, outdated, or misconfigured, the extension won’t work even though it’s installed correctly.

Check Required Runtimes

# Node.js (for many extensions)
node --version  # Should be 18.x or higher for modern extensions

# Python (for Python-related extensions)
python --version  # Check if it matches what the extension expects

# Go
go version

# Java
java -version

Verify PATH Configuration

VS Code inherits your shell’s PATH. If a runtime isn’t in your PATH, extensions can’t find it:

# In VS Code's integrated terminal
echo $PATH

# Check where a binary is located
which python3
which node

If the paths are different from what you expect, you may need to configure terminal.integrated.env:

// settings.json
{
  "terminal.integrated.env.osx": {
    "PATH": "/usr/local/bin:/opt/homebrew/bin:${env:PATH}"
  },
  "terminal.integrated.env.linux": {
    "PATH": "/usr/local/bin:${env:PATH}"
  },
  "terminal.integrated.env.windows": {
    "PATH": "${env:PATH};C:\\Python312;C:\\Python312\\Scripts"
  }
}

Python-Specific Extension Issues

The Python extension is notorious for environment detection problems. If Python IntelliSense isn’t working:

# Select the correct interpreter manually
# Command palette: Python: Select Interpreter

# Or set it directly in settings.json

{
  "python.defaultInterpreterPath": "/path/to/your/venv/bin/python",
  "python.terminal.activateEnvironment": true
}

Check the Python extension output panel for specific errors:

# View → Output → Python

Common errors include:
– Jedi language server failed to start — install Jedi: pip install python-lsp-server
– ruff not found — install: pip install ruff
– pylance could not resolve imports — check your python.analysis.extraPaths

Step 8: Debug Network and Proxy Issues

Corporate proxies, VPNs, and firewall rules can prevent extensions from activating if they need to download components or communicate with external services.

Check Proxy Settings

// settings.json
{
  "http.proxy": "http://proxy.company.com:8080",
  "http.proxyStrictSSL": false,
  "http.proxyAuthorization": null
}

Verify SSL Certificates

If you’re behind a corporate firewall with SSL inspection:

# Set the NODE_EXTRA_CA_CERTS environment variable
# This tells Node.js (which runs extensions) to trust your corporate CA

# Add to your shell profile (~/.bashrc, ~/.zshrc)
export NODE_EXTRA_CA_CERTS=/path/to/corporate-ca.pem

Test Extension Marketplace Connectivity

# Test if you can reach the marketplace
curl -I https://marketplace.visualstudio.com/_apis/public/gallery/

# Expected: HTTP/1.1 200 OK

If this fails, your network is blocking access. You’ll need to either:
1. Whitelist marketplace.visualstudio.com in your firewall
2. Set up an internal extension gallery (for enterprise setups)
3. Download VSIX files from an unrestricted network and install manually

Step 9: Investigate Workspace-Specific Problems

Sometimes extensions work globally but fail in a specific workspace. This is usually caused by workspace settings overriding global configuration.

Check Workspace Settings

# Workspace settings override user settings
.vscode/settings.json

Look for settings that might disable or break extensions:

// Potentially problematic workspace settings
{
  "extensions.recommendations": [],  // Empty recommendations
  "python.languageServer": "None",   // Disables language server
  "typescript.tsserver.enableTracing": false  // May affect TS extensions
}

Check .vscode/extensions.json

This file can restrict which extensions are allowed:

// .vscode/extensions.json
{
  "recommendations": ["ms-python.python"],
  "unwantedRecommendations": ["some.extension"]
}

Trust the Workspace

VS Code has a security feature called Workspace Trust. If a workspace isn’t trusted, many extensions won’t activate:

# Command palette
Workspaces: Manage Workspace Trust

Make sure your workspace is marked as trusted.

Step 10: Advanced Debugging with Developer Tools

When you’ve exhausted standard troubleshooting, VS Code’s Developer Tools give you deep visibility into what’s happening.

Open Developer Tools

# Command palette
Developer: Toggle Developer Tools
# Or keyboard shortcut: Ctrl+Shift+I / Cmd+Option+I

Check the Console tab for errors. Look specifically for:

ERR Extension 'extension.id' is not active: Activation failed
ERR [exthost] [error] SyntaxError: Unexpected token...
ERR rejected extension service

Enable Verbose Logging

# Launch VS Code with verbose logging
code --verbose

# Or set the log level for specific components
code --log extension=debug --log telemetry=debug

Run Extension Host in Inspect Mode

For deep debugging, you can attach a debugger to the extension host:

# Command palette
Developer: Debug Extension Host

This opens a DevTools-like interface specifically for the extension host process, showing you:
– Network requests made by extensions
– Unhandled promise rejections
– Memory usage per extension
– CPU profiling data

Step 11: Edge Cases and Rare Issues

Corrupted User Profile

If you’re using VS Code Profiles (introduced in 1.72), the profile itself may be corrupted:

# List profiles
ls ~/.config/Code/User/profiles/

# Try switching to the Default profile
# Command palette: Profiles: Switch Profile → Default

Multiple VS Code Installations

Having Insiders, Exploration, and stable builds can cause confusion:

# Each variant uses a different extensions folder
~/.vscode/extensions/           # Stable
~/.vscode-insiders/extensions/  # Insiders
~/.vscode-exploration/extensions/ # Exploration

# Check which binary you're actually running
which code
code --version

WSL Extension Issues

If you’re developing in WSL, the WSL extension needs special handling:

# Make sure you're opening VS Code from within WSL
cd /home/user/project
code .

# Reinstall the WSL extension server
# In VS Code: Command palette
WSL: Restart WSL Server

Remote Development Extension Cache

When using Remote-SSH or Remote-Containers, extensions run on the remote host:

“`bash

Clear remote extension cache