What is flat config versus .eslintrc?

Flat config (eslint.config.js) is the default since ESLint 9: an array of config objects evaluated in order. Legacy .eslintrc uses cascading files with extends and env. Most fields map across but plugins and parsers are declared differently.

How do rule severities work?

Each rule maps to off/0, warn/1 or error/2. You can use the string or number, or an array like ["error", { option: true }] to pass rule options after the severity.

How are plugins declared in flat config?

In flat config, plugins is an object mapping a namespace to the imported plugin module, e.g. { import: importPlugin }. Rules from it are then referenced as import/order. Legacy config lists plugin names as strings.

What does files and ignores do?

In flat config, files is an array of glob patterns deciding which files a config object applies to, and ignores excludes paths. A config object with only ignores acts as a global ignore list, replacing .eslintignore.

What replaced parserOptions and env?

Flat config moves parser, parserOptions, globals and ecmaVersion under a single languageOptions object. The old env presets are replaced by importing globals from the globals package into languageOptions.globals.

What is the ESLint Config Schema Reference?

Reference for the ESLint configuration schema covering flat config (eslint.config.js) and legacy .eslintrc fields — rules, plugins, languageOptions, files, ignores and overrides — with types and examples. It runs free in your browser on Gera Tools, with nothing uploaded.

ESLint Config Schema Reference

Name: ESLint Config Schema Reference
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

Get one useful tool a week

Like this tool? Enter your email and we'll send you one genuinely useful Gera tool a week — plus a link to come back to this one. No spam, one-click unsubscribe any time.

Look up ESLint configuration fields fast

ESLint can be configured two ways: the modern flat config in eslint.config.js and the legacy .eslintrc files. This reference lists the fields each format accepts, their types and how plugins and rules are wired in, so you can build or fix a config without digging through docs. It runs entirely in your browser.

Flat config structure

Flat config (default since ESLint 9) exports an array of config objects, each with optional files, ignores, languageOptions, plugins, rules and settings. ESLint merges the objects that match a given file in array order, with later objects winning. Rule severity is off, warn or error (or 0, 1, 2), optionally followed by rule options:

import js from "@eslint/js";
import globals from "globals";

export default [
  js.configs.recommended,
  {
    files: ["**/*.ts"],
    languageOptions: { globals: globals.node, ecmaVersion: 2023 },
    rules: { "no-unused-vars": ["error", { argsIgnorePattern: "^_" }] },
  },
];

Flat config fields at a glance

Field	Type	Purpose
`files`	`string[]`	Glob patterns — which files this config object applies to
`ignores`	`string[]`	Glob patterns to exclude; standalone = global ignore list
`languageOptions`	object	Parser, ecmaVersion, sourceType, globals
`languageOptions.globals`	object	Global variables (from `globals` package)
`languageOptions.parser`	object	Custom parser (e.g. `@typescript-eslint/parser`)
`languageOptions.parserOptions`	object	Parser-specific options (e.g. `project` for type-aware linting)
`plugins`	object	Namespace → plugin module mapping
`rules`	object	Rule name → severity or `[severity, options]`
`settings`	object	Free-form data shared with all rules in this config
`processor`	string or object	Post-processor for non-JS files (e.g. extracting JS from Markdown)

Legacy .eslintrc mapping

If you are migrating from .eslintrc, here is how the key fields map:

`.eslintrc` field	Flat config equivalent
`extends`	Import the config and spread into the array
`env`	`languageOptions.globals` via the `globals` package
`parser`	`languageOptions.parser`
`parserOptions`	`languageOptions.parserOptions`
`plugins` (string array)	`plugins` (namespace-to-module object)
`rules`	`rules` (unchanged)
`settings`	`settings` (unchanged)
`.eslintignore`	Config object with only `ignores`
`overrides`	Additional array entries with `files`

Tips and examples

A flat-config object containing only ignores is a global ignore list and replaces the old .eslintignore file.
Reference a plugin rule by its namespace: register plugins: { import: x }, then enable "import/order": "warn".
Use languageOptions.parser to swap in typescript-eslint’s parser for type-aware linting, paired with parserOptions.project.
The settings object is free-form shared state passed to every rule — this is how plugins like eslint-plugin-import learn your module resolver configuration.
Flat config is evaluated from first to last; when two entries match the same file, the later one’s rules override the earlier one’s for any conflicting rule.