Fix: VSCode ESLint Extension Not Working – No Errors Shown or Not Running

The Error

You open a JavaScript or TypeScript file in VSCode and ESLint does nothing. No red squiggly lines, no warnings in the Problems panel, no output in the ESLint channel. You know the code has issues — running npx eslint . in the terminal catches them — but the editor extension stays silent.

Or you see one of these in the bottom-right corner of VSCode:

ESLint is disabled since its execution has not been approved or denied yet.

ESLint: Failed to load config "..." to extend from.

ESLint server is not running.

ESLint could not find the config file.

Sometimes the extension appears to load but only highlights errors in .js files, ignoring .ts, .tsx, .vue, or .svelte files entirely. Other times it worked yesterday and broke today after an update.

This is one of the most frustrating developer experience issues because there is no single cause. The ESLint extension depends on a chain of things all working together: a local ESLint installation, a valid configuration file, the correct VSCode settings, workspace trust, the right Node.js version, and the proper parser for your file types. A break anywhere in that chain produces the same symptom — silence.

Why This Happens

The VSCode ESLint extension (published by Microsoft, dbaeumer.vscode-eslint) does not bundle its own copy of ESLint. It looks for a locally installed ESLint in your project’s node_modules, loads your configuration file, and runs ESLint as a language server in the background. The results are then displayed as editor diagnostics.

When the extension fails, it is almost always one of these:

• ESLint is not installed locally in the project. The extension does not use a global ESLint installation by default.
• The configuration file format does not match the ESLint version. ESLint 9 uses eslint.config.js (flat config) and ignores .eslintrc.* files. ESLint 8 and below use .eslintrc.* and do not understand eslint.config.js.
• The eslint.validate setting in VSCode does not include your file types. By default the extension only validates JavaScript files.
• Workspace trust is blocking execution. VSCode’s workspace trust feature can prevent extensions from running in untrusted folders.
• The Node.js version used by the extension does not match what ESLint or its plugins require.
• The TypeScript parser is not installed or not configured, so ESLint silently fails on .ts and .tsx files.
• Files are excluded by .eslintignore or the ignores property in flat config, so ESLint intentionally skips them.
• The extension crashed and needs a restart.

The fix depends on which link in the chain is broken. Work through the following sections in order — each one addresses a specific cause and tells you how to confirm whether it applies to your situation.

Fix 1: Install ESLint Locally in Your Project

The most common cause is that ESLint is simply not installed in the project directory. The extension needs a local installation to function.

Check if ESLint is installed:

npx eslint --version

If this fails or returns “command not found,” install ESLint:

npm install --save-dev eslint

After installing, reload the VSCode window. Open the command palette (Ctrl+Shift+P / Cmd+Shift+P) and run “Developer: Reload Window”.

If you have ESLint installed globally but not locally, the extension will not find it unless you explicitly tell it to. However, the recommended approach is always a local installation. Global installations cause version mismatches across projects and make your setup non-reproducible. If a colleague clones your repository and runs npm install, they will get the correct ESLint version automatically — but only if it is in devDependencies.

This also applies to ESLint plugins and parsers. If your config references @typescript-eslint/parser or eslint-plugin-react, those must also be installed locally. A missing parser will not always produce a visible error in the editor — the extension may simply stop linting that file type. If you are seeing ESLint parsing errors in the terminal but nothing in the editor, a missing local parser is the likely cause.

Fix 2: Match Your Config File to Your ESLint Version (Flat Config vs Legacy)

ESLint 9 introduced the flat config format (eslint.config.js) and made it the default. ESLint 8 and below use the legacy format (.eslintrc.js, .eslintrc.json, .eslintrc.yml, or .eslintrc). Using the wrong format for your ESLint version is one of the most common reasons the extension stops working after an upgrade.

Check your ESLint version:

npx eslint --version

If you are on ESLint 9+:

ESLint 9 only reads eslint.config.js (or eslint.config.mjs / eslint.config.cjs). If your project still has a .eslintrc.json or .eslintrc.js, ESLint 9 silently ignores it. The extension will appear to load but no rules are applied because there is no configuration from ESLint’s perspective.

Migrate to flat config or, as a temporary workaround, set the environment variable ESLINT_USE_FLAT_CONFIG=false to force ESLint 9 to read legacy config files.

If you are on ESLint 8 or below:

ESLint 8 does not read eslint.config.js unless you opt in. If someone added a flat config file to your project while the installed ESLint is still v8, ESLint will not find any configuration and will either use defaults (which lint very little) or throw an error.

To confirm which config file ESLint is actually loading, run:

npx eslint --print-config src/index.js

If this outputs a mostly empty configuration or an error about no config found, your config file is not being read.

Fix 3: Set eslint.useFlatConfig in VSCode Settings

The VSCode ESLint extension has a setting that controls whether it tells ESLint to use the flat config format. If this setting is wrong for your project, the extension will fail to load your configuration.

Open your VSCode settings (Ctrl+, / Cmd+,) and search for eslint.useFlatConfig.

• If you are using eslint.config.js with ESLint 9+, set it to true or leave it unset (it defaults to auto-detection in recent versions of the extension).
• If you are using .eslintrc.* with ESLint 8, set it to false or leave it unset.

In your settings.json, this looks like:

{
  "eslint.useFlatConfig": true
}

Or in a workspace .vscode/settings.json:

{
  "eslint.useFlatConfig": true
}

If you have the extension version 3.x or later, it should auto-detect the config format. But older versions of the extension (2.x) do not auto-detect and may need this setting explicitly. Check your extension version in the Extensions panel and update if it is outdated.

Common Mistake: Many developers upgrade ESLint from v8 to v9 without realizing the config file format changed entirely. If your linting silently stopped working after an upgrade, check whether you still have a .eslintrc.* file — ESLint 9 ignores it completely and needs eslint.config.js instead.

Fix 4: Configure eslint.validate for TypeScript, Vue, and Other File Types

By default, the ESLint extension only validates a limited set of languages. If you are writing TypeScript, Vue, Svelte, or other non-standard file types and see no ESLint output, you need to tell the extension to validate those languages.

Add this to your VSCode settings.json:

{
  "eslint.validate": [
    "javascript",
    "javascriptreact",
    "typescript",
    "typescriptreact",
    "vue",
    "svelte",
    "html",
    "markdown"
  ]
}

Only include the languages your project actually uses. If you only work with TypeScript and React, you need at minimum:

{
  "eslint.validate": [
    "javascript",
    "javascriptreact",
    "typescript",
    "typescriptreact"
  ]
}

Without this setting, the extension ignores .ts and .tsx files entirely. You will see no errors, no warnings, and no indication that anything is wrong — ESLint simply never runs on those files. This is a frequent cause of confusion for developers moving from a JavaScript project to TypeScript for the first time.

If you have already configured ESLint with @typescript-eslint/parser and the correct rules but still see nothing in the editor, this setting is almost certainly the problem. Related: if TypeScript itself is throwing module errors, see Fix: Cannot find module or its corresponding type declarations.

Fix 5: Check Workspace Trust Settings

VSCode’s workspace trust feature can prevent the ESLint extension from executing. When you open a folder that VSCode considers “untrusted,” extensions that execute code (including ESLint) are disabled.

Look at the bottom of the VSCode window. If you see a banner saying the workspace is not trusted, click “Trust” or “Manage Workspace Trust” in the banner.

You can also manage trust through the command palette: run “Workspaces: Manage Workspace Trust”.

If you always want to trust a particular folder (for example, your development directory), you can add it to the trusted folders list in VSCode settings. Be cautious about trusting folders you downloaded from unknown sources — workspace trust exists to prevent malicious code in ESLint configs and plugins from running automatically when you open a project.

If the extension was blocked by workspace trust, you will see a message in the ESLint output channel. Which brings us to the next fix.

Fix 6: Check the ESLint Output Panel for Errors

The ESLint extension logs detailed information to its output channel. This is the single most useful diagnostic tool when the extension is not working.

1. Open the Output panel: View > Output (or Ctrl+Shift+U / Cmd+Shift+U).
2. In the dropdown at the top-right of the Output panel, select ESLint.
3. Read the messages.

Common messages and what they mean:

• “Cannot find module ‘eslint’” — ESLint is not installed locally. Go back to Fix 1.
• “ESLint configuration is invalid” — Your config file has a syntax error or references a plugin/config that is not installed.
• “No ESLint configuration found” — ESLint cannot find a config file. Check that your config file is in the project root and matches the expected format for your ESLint version.
• “Failed to load parser ‘@typescript-eslint/parser’” — The TypeScript parser package is not installed. Run npm install --save-dev @typescript-eslint/parser.
• “Unexpected token” during config loading — Your eslint.config.js might use export default syntax but your project does not have "type": "module" in package.json. Rename the file to eslint.config.mjs or add "type": "module".

If the Output panel for ESLint is completely empty, the extension is not running at all. This usually means workspace trust is blocking it or the extension itself failed to activate. Try reloading the window.

Fix 7: Fix Node.js Version Mismatches

The ESLint extension uses Node.js to run ESLint. If the Node.js version it finds is too old for your ESLint installation or plugins, the extension will fail silently or with cryptic errors.

Modern versions of @typescript-eslint/parser (v7+) require Node.js 18 or later. ESLint 9 itself requires Node.js 18.18.0 or later. If your system Node.js is an older version, the extension will not work.

Check which Node.js the extension is using by looking at the ESLint output channel (Fix 6). It often logs the Node.js path and version at startup.

If you use a version manager like nvm, fnm, or Volta, VSCode may not pick up the correct Node.js version because it does not always inherit your shell’s environment. You can explicitly tell the extension which Node.js to use:

{
  "eslint.runtime": "/home/user/.nvm/versions/node/v20.11.0/bin/node"
}

Or set the eslint.nodePath setting to point to the node_modules directory that contains ESLint:

{
  "eslint.nodePath": "./node_modules"
}

If you are unsure which Node.js version is available, run node --version in the VSCode integrated terminal. If that shows v20 but the ESLint extension is failing, the extension might be using a different Node.js binary. Check if the terminal and the extension are using the same one.

When your project depends on a specific Node.js version and things are not resolving correctly, you may also run into Cannot find module errors in Node.js itself — the root cause is often the same: a version mismatch between what you expect and what is actually running.

Fix 8: Install and Configure the TypeScript Parser

If ESLint works for .js files but not .ts or .tsx files, the TypeScript parser is either missing or misconfigured. The default ESLint parser (Espree) does not understand TypeScript syntax. When it encounters a type annotation, it fails — and the extension may swallow that failure instead of showing it.

Install the parser and plugin:

npm install --save-dev @typescript-eslint/parser @typescript-eslint/eslint-plugin

For flat config (eslint.config.js):

import tseslint from 'typescript-eslint';

export default [
  ...tseslint.configs.recommended,
  {
    files: ['**/*.ts', '**/*.tsx'],
    languageOptions: {
      parser: tseslint.parser,
      parserOptions: {
        ecmaVersion: 'latest',
        sourceType: 'module',
      },
    },
  },
];

For legacy config (.eslintrc.json):

{
  "parser": "@typescript-eslint/parser",
  "plugins": ["@typescript-eslint"],
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "parserOptions": {
    "ecmaVersion": "latest",
    "sourceType": "module"
  }
}

After adding the parser, restart the ESLint server: open the command palette and run “ESLint: Restart ESLint Server”. Then check the Output panel for errors.

If you have the parser installed and configured but TypeScript files still are not linted, go back to Fix 4 and make sure eslint.validate includes "typescript" and "typescriptreact".

Fix 9: Check .eslintignore and ignores for Blocked Files

If ESLint works on some files but not others, the ignored files might be excluded by your ignore configuration.

Legacy config: Check .eslintignore in the project root. Also check ignorePatterns in your .eslintrc.* file:

{
  "ignorePatterns": ["dist/", "build/", "*.config.js"]
}

That last pattern (*.config.js) would cause ESLint to ignore any file ending in .config.js — including files you might want linted. Review your ignore patterns carefully.

Flat config: Check the ignores property in eslint.config.js:

export default [
  {
    ignores: ['dist/**', 'build/**', 'coverage/**'],
  },
  // ... rest of config
];

In flat config, an ignores array in a standalone object (without files, rules, or other keys) acts as a global ignore. But ignores inside a config object that also has rules or plugins only applies to that specific config block. This subtlety causes files to be unexpectedly ignored.

To check whether a specific file is being ignored, run:

npx eslint --debug src/components/Button.tsx 2>&1 | grep -i "ignore"

If you see a message about the file being ignored, your ignore configuration is the problem.

Also note that ESLint ignores node_modules by default. If you are working on a file inside a symlinked directory or a monorepo where the resolved path passes through node_modules, ESLint will skip it.

Pro Tip: Before diving into config file debugging, always check the ESLint Output panel first (View > Output > select “ESLint”). Nine times out of ten, the exact error message is already sitting there — saving you from guessing which of the many possible causes applies to your situation.

Fix 10: Restart the ESLint Server and Reload VSCode

The ESLint extension caches configuration and sometimes gets stuck in a bad state. After making any changes to your ESLint config, installed packages, or VSCode settings, you should restart the ESLint server.

Steps in order of aggressiveness:

1. Restart ESLint Server: Open the command palette (Ctrl+Shift+P / Cmd+Shift+P) and run “ESLint: Restart ESLint Server”. This reloads the configuration without restarting the entire editor.

2. Reload Window: If restarting the server does not help, run “Developer: Reload Window” from the command palette. This restarts all extensions.

3. Clear ESLint cache: Delete any cached ESLint data:

rm -f .eslintcache
rm -rf node_modules/.cache/eslint

4. Reinstall the extension: If nothing else works, uninstall the ESLint extension from the Extensions panel, reload VSCode, and reinstall it. This resets any corrupted extension state.

After restarting, always check the ESLint output channel (Fix 6) to see whether the extension loaded successfully this time.

Still Not Working?

Verify ESLint Runs in the Terminal

Before debugging the extension further, confirm that ESLint itself works:

npx eslint src/index.ts

If this command also fails, the problem is not the VSCode extension — it is your ESLint configuration. Fix the CLI first. Common issues include missing dependencies, invalid config syntax, and version mismatches between ESLint and its plugins. If you are seeing dependency resolution errors, check Fix: npm ERR! ERESOLVE unable to resolve dependency tree.

Check for Conflicting Extensions

Other VSCode extensions can interfere with ESLint. Known conflicts include:

• Prettier - Code formatter: If both Prettier and ESLint try to format/lint the same files, they can conflict. Use eslint-config-prettier to disable ESLint rules that conflict with Prettier, or use eslint-plugin-prettier to run Prettier as an ESLint rule.
• Other linting extensions: Extensions like TSLint (deprecated), JSHint, or StandardJS may override or conflict with ESLint diagnostics. Disable them if you are using ESLint.

Try disabling all other extensions temporarily to see if ESLint starts working. If it does, re-enable extensions one by one to find the conflict.

Multi-Root Workspaces

If you use a VSCode multi-root workspace (multiple folders in one window), the ESLint extension resolves configuration per folder. Each folder needs its own node_modules with ESLint installed and its own config file. The extension does not share ESLint installations across workspace folders.

Check the ESLint output channel for messages about which workspace folder it is loading. If one folder works and another does not, the broken folder is likely missing a local ESLint installation or config file.

Environment Variables Not Loaded

If your ESLint config depends on environment variables (for example, conditional rules based on NODE_ENV), those variables may not be set when VSCode launches. The integrated terminal inherits your shell environment, but extensions do not always get the same environment. If your config relies on environment variables that appear undefined, consider hardcoding the values in your ESLint config or using a .env file with a loader.

The Extension Shows “ESLint is disabled”

If you see “ESLint is disabled” in the status bar at the bottom of VSCode, click on it. You may be prompted to allow ESLint to run. The extension requires explicit approval the first time it runs in a workspace. If you previously denied it (accidentally or intentionally), you need to re-approve it.

You can also enable it globally in settings:

{
  "eslint.enable": true
}

And to always approve ESLint execution without prompting:

{
  "eslint.execArgv": null
}

Check eslint.options in Settings

If your VSCode settings include eslint.options, those options are passed directly to the ESLint API. An incorrect option can cause the extension to fail:

{
  "eslint.options": {
    "overrideConfigFile": ".eslintrc.custom.json"
  }
}

If overrideConfigFile points to a file that does not exist, the extension fails silently. Remove or correct any eslint.options you have set and restart the ESLint server.

Last Resort: Debug Logging

Enable verbose logging to get the full picture of what the extension is doing:

{
  "eslint.trace.server": "verbose"
}

Restart the ESLint server, open the ESLint output channel, and reproduce the issue. The verbose log will show every request and response between VSCode and the ESLint language server, including the exact error that caused it to stop linting.

Related: Fix: ESLint Parsing error: Unexpected token | Fix: Cannot find module in Node.js | Fix: npm ERR! ERESOLVE unable to resolve dependency tree | Fix: Environment variable is undefined | Fix: Cannot find module or its corresponding type declarations