Configuration

`$schema`

Allows to pass a path to a JSON schema file.

We publish a JSON schema file for our biome.json/biome.jsonc files.

You can specify a relative path to the schema inside the @biomejs/biome NPM package if it is installed in the node_modules folder:

1
{
2
  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json"
3
}

If you have problems with resolving the physical file, you can use the one published on this site:

1
{
2
  "$schema": "https://biomejs.dev/schemas/2.0.0-beta/schema.json"
3
}

`extends`

A list of paths to other Biome configuration files. Biome resolves and applies the configuration settings from the files contained in the extends list, and eventually applies the options contained in this biome.json/biome.jsonc file.

The order of paths to extend goes from least relevant to most relevant.

`files`

`files.includes`

A list of glob patterns of files to process.

If a folder matches a glob pattern, all files inside that folder will be processed.

The following example matches all files with a .js extension inside the src folder:

1
{
2
  "files": {
3
    "includes": ["src/**/*.js"]
4
  }
5
}

* is used to match all files in a folder, while ** recursively matches all files and subfolders in a folder. For more information on globs, see the glob syntax reference

includes also supports negated patterns, or exceptions. These are patterns that start with ! and they can be used to instruct Biome to process all files except those matching the negated pattern.

Note that exceptions are processed in order, allowing you to specify exceptions to exceptions.

Consider the following example:

1
{
2
  "files": {
3
    "includes": ["**", "!**/*.test.js", "**/special.test.js", "!test"]
4
  }
5
}

This example specifies that:

All files inside all (sub)folders are processed, thanks to the ** pattern…
… except when those files have a .test.js extension…
… but the file special.test.ts is still processed…
… except when it occurs in the folder named test, because no files inside that folder are processed.

This means that:

src/app.js is processed.
src/app.test.js is not processed.
src/special.test.js *is processed.
test/special.test.js *is not processed.

`files.ignoreUnknown`

If true, Biome won’t emit diagnostics if it encounters files that it can’t handle.

1
{
2
  "files": {
3
    "ignoreUnknown": true
4
  }
5
}

Default: false

`files.maxSize`

The maximum allowed size for source code files in bytes. Files above this limit will be ignored for performance reasons.

Default: 1048576 (1024*1024, 1MB)

`vcs`

Set of properties to integrate Biome with a VCS (Version Control Software).

`vcs.enabled`

Whether Biome should integrate itself with the VCS client

Default: false

`vcs.clientKind`

The kind of client.

Values:

"git"

`vcs.useIgnoreFile`

Whether Biome should use the VCS ignore file. When true, Biome will ignore the files specified in the ignore file.

`vcs.root`

The folder where Biome should check for VCS files. By default, Biome will use the same folder where biome.json was found.

If Biome can’t find the configuration, it will attempt to use the current working directory. If no current working directory can’t be found, Biome won’t use the VCS integration, and a diagnostic will be emitted

`vcs.defaultBranch`

The main branch of the project. Biome will use this branch when evaluating the changed files.

`linter`

`linter.enabled`

Enables Biome’s linter.

Default: true

`linter.includes`

A list of glob patterns of files to lint.

The following example lints all files with a .js extension inside the src folder:

1
{
2
  "linter": {
3
    "includes": ["src/**/*.js"]
4
  }
5
}

* is used to match all files in a folder, while ** recursively matches all files and subfolders in a folder. For more information on globs, see the glob syntax reference

Note that exceptions are processed in order, allowing you to specify exceptions to exceptions.

Consider the following example:

1
{
2
  "linter": {
3
    "includes": ["**", "!**/*.test.js", "**/special.test.js"]
4
  }
5
}

This example specifies that:

All files inside all (sub)folders are linted, thanks to the ** pattern…
… except when those files have a .test.js extension…
… but the file special.test.ts is still linted.

This means that:

src/app.js is linted.
src/app.test.js is not linted.
src/special.test.js *is linted.

Note that linter.includes is applied after files.includes. This means that any file that is not matched by files.includes can no longer be matched linter.includes. This means the following example doesn’t work:

1
{
2
  "files": {
3
    "includes": "src/**"
4
  },
5
  "linter": {
6
    // This matches nothing because there is no overlap with `files.includes`:
7
    "includes": "scripts/**"
8
  }
9
}

If linter.includes is not specified, all files matched by files.includes are linted.

`linter.rules.recommended`

Enables the recommended rules for all groups.

Default: true

`linter.rules.[group]`

Options that influence the rules of a single group. Biome supports the following groups:

accessibility: Rules focused on preventing accessibility problems.
complexity: Rules that focus on inspecting complex code that could be simplified.
correctness: Rules that detect code that is guaranteed to be incorrect or useless.
nursery: New rules that are still under development. Nursery rules require explicit opt-in via configuration on stable versions because they may still have bugs or performance problems. They are enabled by default on nightly builds, but as they are unstable their diagnostic severity may be set to either error or warning, depending on whether we intend for the rule to be recommended or not when it eventually gets stabilized. Nursery rules get promoted to other groups once they become stable or may be removed. Rules that belong to this group are not subject to semantic version.
performance: Rules catching ways your code could be written to run faster, or generally be more efficient.
security: Rules that detect potential security flaws.
style: Rules enforcing a consistent and idiomatic way of writing your code.
suspicious: Rules that detect code that is likely to be incorrect or useless.

Each group can accept, as a value, a string that represents the severity or an object where each rule can be configured.

When passing the severity, you can control the severity emitted by all the rules that belong to a group. For example, you can configure the a11y group to emit information diagnostics:

1
{
2
  "linter": {
3
    "rules": {
4
      "a11y": "info"
5
    }
6
  }
7
}

Here are the accepted values:

"on": each rule that belongs to the group will emit a diagnostic with the default severity of the rule. Refer to the documentation of the rule, or use the explain command:
Terminal window
```
biome explain noDebugger
```
"off": none of the rules that belong to the group will emit any diagnostics.
"info": all rules that belong to the group will emit a diagnostic with information severity.
"warn": all rules that belong to the group will emit a diagnostic with warning severity.
"error": all rules that belong to the group will emit a diagnostic with error severity.

`linter.rules.[group].recommended`

Enables the recommended rules for a single group.

Example:

1
{
2
  "linter": {
3
    "enabled": true,
4
    "rules": {
5
      "nursery": {
6
        "recommended": true
7
      }
8
    }
9
  }
10
}

`formatter`

These options apply to all languages. There are additional language-specific formatting options below.

`formatter.enabled`

Enables Biome’s formatter.

Default: true

`formatter.includes`

A list of glob patterns of files to format.

The following example formats all files with a .js extension inside the src folder:

1
{
2
  "formatter": {
3
    "includes": ["src/**/*.js"]
4
  }
5
}

* is used to match all files in a folder, while ** recursively matches all files and subfolders in a folder. For more information on globs, see the glob syntax reference

Note that exceptions are processed in order, allowing you to specify exceptions to exceptions.

Consider the following example:

1
{
2
  "formatter": {
3
    "includes": ["**", "!**/*.test.js", "**/special.test.js"]
4
  }
5
}

This example specifies that:

All files inside all (sub)folders are formatted, thanks to the ** pattern…
… except when those files have a .test.js extension…
… but the file special.test.ts is still formatted.

This means that:

src/app.js is formatted.
src/app.test.js is not formatted.
src/special.test.js *is formatted.

Note that formatter.includes is applied after files.includes. This means that any file that is not matched by files.includes can no longer be matched formatter.includes. This means the following example doesn’t work:

1
{
2
  "files": {
3
    "includes": "src/**"
4
  },
5
  "formatter": {
6
    // This matches nothing because there is no overlap with `files.includes`:
7
    "includes": "scripts/**"
8
  }
9
}

If formatter.includes is not specified, all files matched by files.includes are formatted.

`formatter.formatWithErrors`

Allows to format a document that has syntax errors.

1
{
2
  "formatter": {
3
    "formatWithErrors": true
4
  }
5
}

Default: false

`formatter.indentStyle`

The style of the indentation. It can be "tab" or "space".

Default: "tab"

`formatter.indentWidth`

How big the indentation should be.

Default: 2

`formatter.lineEnding`

The type of line ending.

"lf", Line Feed only (\n), common on Linux and macOS as well as inside git repos;
"crlf", Carriage Return + Line Feed characters (\r\n), common on Windows;
"cr", Carriage Return character only (\r), used very rarely.

Default: "lf"

`formatter.lineWidth`

The amount of characters that can be written on a single line..

Default: 80

`formatter.attributePosition`

The attribute position style in HTMLish languages.

"auto", the attributes are automatically formatted, and they will collapse in multiple lines only when they hit certain criteria;
"multiline", the attributes will collapse in multiple lines if more then 1 attribute is used.

Default: "auto"

`formatter.bracketSpacing`

Choose whether spaces should be added between brackets and inner values.

Default: true

`formatter.objectWrap`

Whether to enforce collapsing object literals when possible.

"preserve", object literals are expanded if the first property has a leading newline.
"collapse", enforce object literals to collapse if possible (shorter than the max line width).

Default: "preserve"

`formatter.useEditorconfig`

Whether Biome should use the .editorconfig file to determine the formatting options.

The config files .editorconfig and biome.json will follow the follwing rules:

Formatting settings in biome.json always take precedence over .editorconfig files.
.editorconfig files that exist higher up in the hierarchy than a biome.json file are already ignored. This is to avoid loading formatting settings from someone’s home directory into a project with a biome.json file.
Nested .editorconfig files aren’t supported currently.

Default: true

`javascript`

These options apply only to JavaScript (and TypeScript) files.

`javascript.parser.unsafeParameterDecoratorsEnabled`

Allows to support the unsafe/experimental parameter decorators.

1
{
2
  "javascript": {
3
    "parser": {
4
      "unsafeParameterDecoratorsEnabled": true
5
    }
6
  }
7
}

Default: false

`javascript.parser.jsxEverywhere`

When set to true, allows to parse JSX syntax inside .js files. When set to false, Biome will raise diagnostics when it encounters JSX syntax inside .js files.

Default: true

1
{
2
  "javascript": {
3
    "parser": {
4
      "jsxEverywhere": false
5
    }
6
  }
7
}

`javascript.formatter.quoteStyle`

The type of quote used when representing string literals. It can be "single" or "double".

Default: "double"

`javascript.formatter.jsxQuoteStyle`

The type of quote used when representing jsx string literals. It can be "single" or "double".

Default: "double"

1
{
2
  "javascript": {
3
    "formatter": {
4
      "jsxQuoteStyle": "single"
5
    }
6
  }
7
}

`javascript.formatter.quoteProperties`

When properties inside objects should be quoted. It can be "asNeeded" or "preserve".

Default: "asNeeded"

1
{
2
  "javascript": {
3
    "formatter": {
4
      "quoteProperties": "preserve"
5
    }
6
  }
7
}

`javascript.formatter.trailingCommas`

Print trailing commas wherever possible in multi-line comma-separated syntactic structures. Possible values:

"all", the trailing comma is always added;
"es5", the trailing comma is added only in places where it’s supported by older version of JavaScript;
"none", trailing commas are never added.

Default: "all"

`javascript.formatter.semicolons`

It configures where the formatter prints semicolons:

"always", the semicolons is always added at the end of each statement;
"asNeeded", the semicolons are added only in places where it’s needed, to protect from ASI.

Default: "always"

Example:

1
{
2
  "javascript": {
3
    "formatter": {
4
      "semicolons": "asNeeded"
5
    }
6
  }
7
}

`javascript.formatter.arrowParentheses`

Whether to add non-necessary parentheses to arrow functions:

"always", the parentheses are always added;
"asNeeded", the parentheses are added only when they are needed.

Default: "always"

`javascript.formatter.enabled`

Enables Biome’s formatter for JavaScript (and its super languages) files.

Default: true

`javascript.formatter.indentStyle`

The style of the indentation for JavaScript (and its super languages) files. It can be "tab" or "space".

Default: "tab"

`javascript.formatter.indentWidth`

How big the indentation should be for JavaScript (and its super languages) files.

Default: 2

`javascript.formatter.lineEnding`

The type of line ending for JavaScript (and its super languages) files.

"lf", Line Feed only (\n), common on Linux and macOS as well as inside git repos;
"crlf", Carriage Return + Line Feed characters (\r\n), common on Windows;
"cr", Carriage Return character only (\r), used very rarely.

Default: "lf"

`javascript.formatter.lineWidth`

The amount of characters that can be written on a single line in JavaScript (and its super languages) files.

Default: 80

`javascript.formatter.bracketSameLine`

Choose whether the ending > of a multi-line JSX element should be on the last attribute line or not

Default: false

`javascript.formatter.bracketSpacing`

Choose whether spaces should be added between brackets and inner values.

Default: true

`javascript.formatter.attributePosition`

The attribute position style in jsx elements.

"auto", do not enforce single attribute per line.
"multiline", enforce single attribute per line.

Default: "auto"

`javascript.formatter.objectWrap`

Whether to enforce collapsing object literals when possible.

"preserve", object literals are expanded if the first property has a leading newline.
"collapse", enforce object literals to collapse if possible (shorter than the max line width).

Default: "preserve"

`javascript.globals`

A list of global names that Biome should ignore (analyzer, linter, etc.)

1
{
2
  "javascript": {
3
    "globals": ["$", "_", "externalVariable"]
4
  }
5
}

`javascript.jsxRuntime`

Indicates the type of runtime or transformation used for interpreting JSX.

"transparent" — Indicates a modern or native JSX environment, that doesn’t require special handling by Biome.
"reactClassic" — Indicates a classic React environment that requires the React import. Corresponds to the react value for the jsx option in TypeScript’s tsconfig.json.

1
{
2
  "javascript": {
3
    "jsxRuntime": "reactClassic"
4
  }
5
}

For more information about the old vs. new JSX runtime, please see: https://legacy.reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html

Default: "transparent"

`javascript.linter.enabled`

Enables Biome’s linter for JavaScript (and its super languages) files.

Default: true

1
{
2
  "javascript": {
3
    "linter": {
4
      "enabled": false
5
    }
6
  }
7
}

`javascript.assist.enabled`

Enables Biome’s assist for JavaScript (and its super languages) files.

Default: true

1
{
2
  "javascript": {
3
    "assist": {
4
      "enabled": false
5
    }
6
  }
7
}

`json`

Options applied to the JSON files.

`json.parser.allowComments`

Enables the parsing of comments in JSON files.

1
{
2
  "json": {
3
    "parser": {
4
      "allowComments": true
5
    }
6
  }
7
}

`json.parser.allowTrailingCommas`

Enables the parsing of trailing commas in JSON files.

1
{
2
  "json": {
3
    "parser": {
4
      "allowTrailingCommas": true
5
    }
6
  }
7
}

`json.formatter.enabled`

Enables Biome’s formatter for JSON (and its super languages) files.

Default: true

1
{
2
  "json": {
3
    "formatter": {
4
      "enabled": false
5
    }
6
  }
7
}

`json.formatter.indentStyle`

The style of the indentation for JSON (and its super languages) files. It can be "tab" or "space".

Default: "tab"

`json.formatter.indentWidth`

How big the indentation should be for JSON (and its super languages) files.

Default: 2

`json.formatter.lineEnding`

The type of line ending for JSON (and its super languages) files.

"lf", Line Feed only (\n), common on Linux and macOS as well as inside git repos;
"crlf", Carriage Return + Line Feed characters (\r\n), common on Windows;
"cr", Carriage Return character only (\r), used very rarely.

Default: "lf"

`json.formatter.lineWidth`

The amount of characters that can be written on a single line in JSON (and its super languages) files.

Default: 80

`json.formatter.trailingCommas`

Print trailing commas wherever possible in multi-line comma-separated syntactic structures.

Allowed values:

"none": the trailing comma is removed;
"all": the trailing comma is kept and preferred.

Default: "none"

`json.formatter.bracketSpacing`

Choose whether spaces should be added between brackets and inner values.

Default: true

`json.formatter.objectWrap`

Whether to enforce collapsing object literals when possible.

"preserve", object literals are expanded if the first property has a leading newline.
"collapse", enforce object literals to collapse if possible (shorter than the max line width).

Default: "preserve"

`json.formatter.expand`

Whether to expand arrays and objects literals on multiple lines.

"followSource": arrays and objects literals are formatted on multiple lines if they already were on multiple lines, or if they don’t fit on a single line.
"always": arrays and objects literals are formatted on multiple lines, regardless of length of the list.

When formatting package.json, Biome will use always unless configured otherwise.

Default: "followSource"

`json.linter.enabled`

Enables Biome’s formatter for JSON (and its super languages) files.

Default: true

1
{
2
  "json": {
3
    "linter": {
4
      "enabled": false
5
    }
6
  }
7
}

`json.assist.enabled`

Enables Biome’s assist for JSON (and its super languages) files.

Default: true

1
{
2
  "json": {
3
    "assist": {
4
      "enabled": false
5
    }
6
  }
7
}

`css`

Options applied to the CSS files.

`css.parser.cssModules`

Enables parsing of CSS modules

Default: false

`css.formatter.enabled`

Enables Biome’s formatter for CSS files.

Default: false

1
{
2
  "css": {
3
    "formatter": {
4
      "enabled": false
5
    }
6
  }
7
}

`css.formatter.indentStyle`

The style of the indentation for CSS files. It can be "tab" or "space".

Default: "tab"

`css.formatter.indentWidth`

How big the indentation should be for CSS files.

Default: 2

1
{
2
  "css": {
3
    "formatter": {
4
      "indentWidth": 2
5
    }
6
  }
7
}

`css.formatter.lineEnding`

The type of line ending for CSS files.

"lf", Line Feed only (\n), common on Linux and macOS as well as inside git repos;
"crlf", Carriage Return + Line Feed characters (\r\n), common on Windows;
"cr", Carriage Return character only (\r), used very rarely.

Default: "lf"

`css.formatter.lineWidth`

The amount of characters that can be written on a single line in CSS files.

Default: 80

`css.formatter.quoteStyle`

The type of quote used when representing string literals. It can be "single" or "double".

Default: "double"

`css.linter.enabled`

Enables Biome’s linter for CSS files.

Default: true

1
{
2
  "css": {
3
    "linter": {
4
      "enabled": false
5
    }
6
  }
7
}

`css.assist.enabled`

Enables Biome’s assist for CSS files.

Default: true

1
{
2
  "css": {
3
    "assist": {
4
      "enabled": false
5
    }
6
  }
7
}

`graphql`

Options applied to the GraphQL files.

`graphql.formatter.enabled`

Enables Biome’s formatter for GraphQL files.

Default: false

`graphql.formatter.indentStyle`

The style of the indentation for GraphQL files. It can be "tab" or "space".

Default: "tab"

`graphql.formatter.indentWidth`

How big the indentation should be for GraphQL files.

Default: 2

`graphql.formatter.lineEnding`

The type of line ending for GraphQL files.

"lf", Line Feed only (\n), common on Linux and macOS as well as inside git repos;
"crlf", Carriage Return + Line Feed characters (\r\n), common on Windows;
"cr", Carriage Return character only (\r), used very rarely.

Default: "lf"

`graphql.formatter.lineWidth`

The amount of characters that can be written on a single line in GraphQL files.

Default: 80

`graphql.formatter.quoteStyle`

The type of quote used when representing string literals. It can be "single" or "double".

Default: "double"

`graphql.linter.enabled`

Enables Biome’s linter for GraphQL files.

Default: true

`graphql.assist.enabled`

Enables Biome’s assist for GraphQL files.

Default: true

`grit`

Options applied to the Grit files.

`grit.formatter.enabled`

Enables Biome’s formatter for Grit files.

Default: false

`grit.formatter.indentStyle`

The style of the indentation for Grit files. It can be "tab" or "space".

Default: "tab"

`grit.formatter.indentWidth`

How big the indentation should be for Grit files.

Default: 2

`grit.formatter.lineEnding`

The type of line ending for Grit files.

"lf", Line Feed only (\n), common on Linux and macOS as well as inside git repos;
"crlf", Carriage Return + Line Feed characters (\r\n), common on Windows;
"cr", Carriage Return character only (\r), used very rarely.

Default: "lf"

`grit.formatter.lineWidth`

The amount of characters that can be written on a single line in Grit files.

Default: 80

`grit.formatter.quoteStyle`

The type of quote used when representing string literals. It can be "single" or "double".

Default: "double"

`grit.linter.enabled`

Enables Biome’s linter for Grit files.

Default: true

1
{
2
  "grit": {
3
    "linter": {
4
      "enabled": false
5
    }
6
  }
7
}

`grit.assist.enabled`

Enables Biome’s assist for Grit files.

Default: true

1
{
2
  "grit": {
3
    "assist": {
4
      "enabled": false
5
    }
6
  }
7
}

`overrides`

A list of patterns.

Use this configuration to change the behaviour of the tools for certain files.

When a file is matched against an override pattern, the configuration specified in that pattern will be override the top-level configuration.

The order of the patterns matter. If a file can match three patterns, only the first one is used.

`overrides.<ITEM>.includes`

A list of glob patterns of files for which to apply customised settings.

1
{
2
  "overrides": [{
3
    "includes": ["scripts/*.js"],
4
    // settings that should only apply to the files specified in the includes field.
5
  }]
6
}

`overrides.<ITEM>.formatter`

It will include the options of top level formatter configuration, minus ignore and include.

Examples

For example, it’s possible to modify the formatter lineWidth, indentStyle for certain files that are included in the glob path generated/**:

1
{
2
  "formatter": {
3
    "lineWidth": 100
4
  },
5
  "overrides": [
6
    {
7
      "includes": ["generated/**"],
8
      "formatter": {
9
        "lineWidth": 160,
10
        "indentStyle": "space"
11
      }
12
    }
13
  ]
14
}

`overrides.<ITEM>.linter`

It will include the options of top level linter configuration, minus ignore and include.

Examples

You can disable certain rules for certain glob paths, and disable the linter for other glob paths:

1
{
2
  "linter": {
3
    "enabled": true,
4
    "rules": {
5
      "recommended": true
6
    }
7
  },
8
  "overrides": [
9
    {
10
      "includes": ["lib/**"],
11
      "linter": {
12
        "rules": {
13
          "suspicious": {
14
            "noDebugger": "off"
15
          }
16
        }
17
      }
18
    },
19
    {
20
      "includes": ["shims/**"],
21
      "linter": {
22
        "enabled": false
23
      }
24
    }
25
  ]
26
}

`overrides.<ITEM>.organizeImports`

It will include the options of top level organize imports, minus ignore and include.

`overrides.<ITEM>.javascript`

It will include the options of top level javascript configuration.

Examples

You can change the formatting behaviour of JavaScript files in certain folders:

1
{
2
  "formatter": {
3
    "lineWidth": 120
4
  },
5
  "javascript": {
6
    "formatter": {
7
      "quoteStyle": "single"
8
    }
9
  },
10
  "overrides": [
11
    {
12
      "includes": ["lib/**"],
13
      "javascript": {
14
        "formatter": {
15
          "quoteStyle": "double"
16
        }
17
      }
18
    }
19
  ]
20
}

`overrides.<ITEM>.json`

It will include the options of top level json configuration.

Examples

You can enable parsing features for certain JSON files:

1
{
2
  "linter": {
3
    "enabled": true,
4
    "rules": {
5
      "recommended": true
6
    }
7
  },
8
  "overrides": [
9
    {
10
      "includes": [".vscode/**"],
11
      "json": {
12
        "parser": {
13
          "allowComments": true,
14
          "allowTrailingCommas": true
15
        }
16
      }
17
    }
18
  ]
19
}

Glob syntax reference

Glob patterns are used to match paths of files and folders. Biome supports the following syntax in globs:

* matches zero or more characters. It cannot match the path separator /.
** recursively matches directories and files. This sequence must be used as an entire path component, so both **a and b** are invalid and will result in an error. A sequence of more than two consecutive * characters is also invalid.
[...] matches any character inside the brackets. Ranges of characters can also be specified, as ordered by Unicode, so e.g. [0-9] specifies any character between 0 and 9 inclusive.
[!...] is the negation of [...], i.e. it matches any characters not in the brackets.
If the entire glob starts with !, it is a so-called negated pattern. This glob only matches if the path doesn’t match the glob. Negated patterns cannot be used alone, they can only be used as exception to a regular glob.

Some examples:

dist/** matches the dist/ folder and all files inside it.
**/test/** matches all files under any folder named test, regardless of where they are. E.g. dist/test, src/test.
**/*.js matches all files ending with the extension .js in all folders.