NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
npm · #3053 most downloaded on npm
Biome is a toolchain for the web: formatter, linter and more
Last release 4 days ago
30 Sep 2026
Ships on a steady schedule
a new release about every 2 weeks
Nearly every release is documented
notes for 60 of the last 60 stable releases
3 versions withdrawn
withdrawn after publishing
3 years old
154 releases · first in 2023
One column per quarter.
Breaking Change: The option deniedGlobals is now a record instead of an array. Run biome migrate to migrate the configuration automatically.
Biome now resolves globs and paths from the configuration. Before, paths and globs were resolved from the working directory.
Biome now raises a warning diagnostic for suppression comments that have <explanation> as reason.
<explanation> is provided as a placeholder when applying the suppression code fix from LSP editors.
Removed the --config-path argument from the biome lsp-proxy and biome start commands.
The option was overriding the configuration path for all workspaces opened in the Biome daemon, which led to a configuration mismatch problem when multiple projects are opened in some editors or IDEs.
If you are using one of our official plugins for IDEs or editors, it is recommended to update it to the latest version of the plugin, or you will get unexpected behavior.
If you are a developer of a plugin, please update your plugin to use the
workspace/configuration response instead of using the
--config-path argument. Biome's LSP will resolve a configuration in the workspace automatically, so it is recommended to keep it empty unless you are using a custom configuration path.
Downgraded some code fixes to unsafe which were previously safe.
The following rules have now a unsafe fix:
If you want to keep applying these fixes automatically, configure the rule fix as safe:
{
"linter": {
"rules": {
"correctness": {
"noFlatMapIdentity": {
"level": "error",
"fix": "safe"
},
"noUnusedImports": {
"level": "error",
"fix": "safe"
}
}
}
}
}
Previously the lint rules noControlCharactersInRegex and
noMisleadingCharacterClass checked both regular expression literals like
/regex/ and dynamically built regular expressions like new RegExp("regex").
Checking dynamically built regular expressions has many limitations, edge cases, and complexities. In addition, other rules that lint regular expressions don't check dynamically built regular expressions.
Rather than add support for other rules and have half-baked checking, we decided to remove support for dynamically built regular expressions.
Now the lint rules noControlCharactersInRegex and
noMisleadingCharacterClass only check literals of regular expressions.
The lint rule noRestrictedGlobals now supports customizing message for each global name.
For example, the following configuration:
{
"options": {
"deniedGlobals": {
"$": "jQuery is not allowed. Use native DOM manipulation instead."
}
}
}
emits a diagnostic:
index.js:1:13 lint/style/noRestrictedGlobals ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠ Do not use the global variable $.
> 1 │ console.log($)
│ ^
2 │
ℹ jQuery is not allowed. Use native DOM manipulation instead.
Breaking Change: The option deniedGlobals is now a record instead of an array. Run
biome migrate to migrate the configuration automatically.
Removed include and ignore fields in favor of the new field includes.
The Biome configuration file allows users to specify which files should be processed using glob patterns. Prior to Biome 2.0, this was done using the
include and ignore fields. In Biome 2.0, include and ignore are removed and replaced by
includes. You can run biome migrate to convert include and ignore into includes automatically.
includes uses a different glob pattern format that fixes many issues and many other limitations that Biome users reported.
includes accepts an array of glob patterns. A glob pattern starting with a
! is a negated pattern also called exception. This replaces
ignore patterns and allows users to create chains of include and ignore patterns. Thus, it is now possible to include again a file previously ignored. This was not possible with
include and ignore, because ignore has priority over include.
The semantics of * and **/* have changed too. Before, with include and ignore, the glob * was interpreted as
**/*. Now, with includes, the globs * and
**/* are interpreted differently. The first pattern matches all files that are inside a folder. The second pattern recursively matches all files
and sub-folders inside a folder.
Let's take an example. Given the following file hierarchy of a project...
├── biome.json
├── src
│ ├── file.js
│ ├── file.ts
│ ├── out.gen.js
│ ├── file.test.js
│ └── test
│ └── special.test.js
└── test ...
...we want:
.test.js, except special.test.ts.test directory. The test directory is located at the root of the project.src directory, that don't end with .gen.js. The
src directory is located at the root of the project.noDefaultExport lint rule on files ending with .ts.Prior to Biome 2.0, the configuration might look like:
{
"files": {
"ignore": ["*.test.js", "test"]
},
"linter": {
"include": ["src/**"],
"ignore": ["*.gen.js"],
"enabled": true
},
"overrides": [
{
"include": ["*.ts"],
"linter": { "rules": { "style": { "noDefaultExport": "on" } } }
}
]
}
Unfortunately, the configuration doesn't quite fit what we want:
.test.js, including special.test.ts.test, including src/test.srcAll these issues and limitations are fixed with includes. Here the migrated configuration:
{
"files": {
"includes": ["**", "!**/*.test.js", "**/special.test.ts", "!test"]
},
"linter": {
"includes": ["src/**", "!**/*.gen.js"],
"enabled": true
},
"overrides": [
{
"includes": ["**/*.ts"],
"linter": { "rules": { "style": { "noDefaultExport": "on" } } }
}
]
}
special.test.ts are unignored because the pattern appear after the pattern that ignore files ending with
.test.js.test directory at the project's root is ignored because the pattern doesn't start with **/.src directory at the project's root only.Because includes pattern have a different pattern format than include and ignore we made some adjustments:
** in files.includes to ensure that all files are included before ignoring some of them.**/ for patterns that must match at any level of the file hierarchy.noUndeclaredVariables no longer reports TypeScript types.
In TypeScript projects, developers often use global declaration files to declare global types. Biome is currently unable to detect these global types. This creates many false positives for
noUndeclaredVariables.
TypeScript is better suited to perform this kind of check. As proof of this, TypeScript ESLint doesn't provide any rule that extends the
no-undef ESLint rule.
This is why Biome 1.9 introduced a new option
checkTypes which, when it is set to false, ignores undeclared type references. The option was set to
true by default.
This option is now set to false by default. To get the previous behavior, you have to set checkTypes to true:
{
"linter": {
"rules": {
"correctness": {
"noUndeclaredVariables": {
"level": "on",
"options": { "checkTypes": true }
}
}
}
}
}
The rule noUnusedVariables no longer reports unused function parameters. Use noUnusedFunctionParameters.
Fixed #5564.
noTypeOnlyImportAttributes now ignores files ending with the extension .ts when the type field of
package.json is set to commonjs.
The Biome formatter no longer adds a trailing comma in .json files, even when
json.formatter.trailingCommas is set to true.
Prettier 3.4 introduced a change in their normalization process of string literals: it no longer unescapes useless escape sequences. Biome now matches the new behavior of Prettier when formatting code. This affects the JSON and JavaScript formatters.
Reduced accepted values for formatter options:
--quote-style doesn't accept Single and Double anymore.--quote-properties doesn't accept AsNeeded and Preserve anymore.--semicolons doesn't accept AsNeeded and Always anymore.--arrow-parenthesis doesn't accept AsNeeded and Always anymore.--trailing-commas doesn't accept ES5, All and None anymore.--attribute-position doesn't accept Single and Multiline anymore.Removed the option enumMemberCase from the lint rule useNamingConvention.
enumMemberCase is an option that allows to customize the enforced case for TypeScript's enum members. The option was introduced prior to the
conventions option that allows to do the same thing.
The following configuration...
{
"linter": {
"rules": {
"style": {
"useNamingConvention": {
"level": "on",
"options": {
"enumMemberCase": "PascalCase"
}
}
}
}
}
}
...must be rewritten as:
{
"linter": {
"rules": {
"style": {
"useNamingConvention": {
"level": "on",
"options": {
"conventions": [
{
"selector": { "kind": "enumMember" },
"formats": ["PascalCase"]
}
]
}
}
}
}
}
}
Run biome migrate --write to turn enumMemberCase into conventions automatically.
Removed support for BIOME_LOG_DIR.
The environment variable BIOME_LOG_DIR isn't supported anymore.
Use BIOME_LOG_PATH instead.
Remove deprecated rules.
The following deprecated rules have been deleted:
noInvalidNewBuiltinnoNewSymboluseShorthandArrayTypeuseSingleCaseStatementnoConsoleLogRun the command biome migrate --write to update the configuration.
Removed the deprecated indentSize option.
The deprecated option indentSize, and its relative CLI options, has been removed:
formatter.indentSizejavascript.formatter.indentSizejson.formatter.indentSize--indent-size--javascript-formatter-indent-size--json-formatter-indent-sizeUse indentWidth and its relative CLI options instead.
Removed ROME_BINARY. Use BIOME_BINARY instead.
Removed support for legacy suppressions.
Biome used to support "legacy suppressions" that looked like this:
// biome-ignore lint(complexity/useWhile): reason
This format is no longer supported.
Removed support for max_line_length from .editorconfig, as it isn't part of the official spec anymore.
Removed support for rome-ignore suppression comments.
Use biome-ignore suppression comments instead.
Removed support for rome.json.
Use biome.json or biome.jsonc instead.
Removed the option all from the linter.
The options linter.rules.all and linter.rules.<group>.all has been removed.
The number of rules in Biome have increased in scope and use cases, and sometimes some of them can conflict with each other.
The option was useful at the beginning, but now it's deemed harmful, because it can unexpected behaviours in users projects.
To automatically remove it, run the following command:
biome migrate --write
Removed the option trailingComma from the configuration and the CLI. Use the option trailingCommas instead:
{
"javascript": {
"formatter": {
- "trailingComma": "es5"
+ "trailingCommas": "es5"
}
}
}
-biome format --trailing-comma=es5
+biome format --trailing-commas=es5
Removed --apply and --apply-unsafe.
The CLI options --apply and --apply-unasfe aren't accepted anymore. Use --write and --write --unafe instead:
-biome check --apply-unsafe
+biome check --write --unsafe
-biome check --apply
+biome check --write
Removed support for assert syntax.
Biome now longer supports the assert syntax, use the new with syntax instead
-import {test} from "foo.json" assert { for: "for" }
-export * from "mod" assert { type: "json" }
+import {test} from "foo.json" with { for: "for" }
+export * from "mod" with { type: "json" }
Fixed #5495: The rule
noBlankTarget has been updated to accept the
rel="noopener" in addition to rel="noreferrer". In addition, an option has been added that allows
rel="noreferrer" to be disabled.
The rule has been moved from the a11y group to the security group.
The rule useImportRestrictions has been renamed to noPrivateImports, and its functionality has been significantly upgraded.
Previously, the rule would assume that any direct imports from modules inside other directories should be forbidden due to their package private visibility.
The updated rule allows configuring the default visibility of exports, and recognises JSDoc comments to override this visibility. The default visibility is now
**public**, but can be set to **package**, or even
**private**. Refer to the documentation of the rule to understand how to leverage the JSDoc comments.
noPrivateImports is now recommended by default.
The Biome daemon now reuses its workspace across connections. This allows multiple clients to reuse the same documents and other cached data that we extract from them.
This primarily affects our IDE extensions: If you open multiple IDEs/windows for the same project, they'll connect to the same daemon and reuse each other's workspace.
The Biome CLI is unaffected unless you opt in with the --use-server argument.
Biome no longer treats too large files as errors.
Previously, files that exceed the configured size limit would throw an error, and the CLI would exit with an error code.
Now, the CLI ignores the file, emits an information diagnostic and doesn't exit with an error code.
Change the group of some rules, promote nursery rules and update the recommended rule set.
The following rules have been moved to a new group:
New rules are incubated in the nursery group. Once stable, we promote them to a stable group. Use the
biome migrate command to automatically migrate nursery rules that have been promoted.
The following CSS rules have been promoted:
The following GraphQL rules have been promoted:
The following JavaScript rules have been promoted:
Moreover, the following JavaScript rules are now recommended:
And the following style rules are no longer recommended:
Update the default severity level of lint rules.
Every diagnostic emitted by Biome has a severity level set to error, warn, or
info. Previously, all recommended lint rules had a default severity level set to
error. All other lint rules had a default severity level set to warn.
We have adjusted the default severity level of every rule, whether recommended or not, to better communicate the severity that a diagnostic highlights.
error.warn.info.You can use the CLI option --diagnostic-level=error to display only errors, or
--diagnostic-level=warning to display both errors and warnings. By default, all diagnostics are shown. You can also use the CLI option
--error-on-warnings to make the command fail when warnings are emitted.
Reworked some recommended rules recommended to be less pedantic and blocking. This is a **breaking change ** if your project relied on those rules to block the CI in case of violations; if that's the case, you should raise their severity level to error.
Some rules aren't recommended anymore, and some others return a different severity.
The following rules return a warning diagnostic:
noDeletenoForEachnoSuspiciousSemicolonInJsxnoThisInStaticnoUnusedLabelsThe following rules return an information diagnostic:
noUselessCatchnoUselessConstructornoUselessEmptyExportnoUselessFragmentsnoUselessLabelnoUselessLoneBlockStatementsnoUselessSwitchCasenoUselessTernarynoUselessThisAliasnoUselessTypeConstraintnoFlatMapIdentityThe following rules aren't recommended anymore:
noDeletenoForEachThe rule noRenderReturnValue and useExhaustiveDependencies are only recommended when the
react domain is enabled.
Renamed the global option --skip-errors to --skip-parse-errors.
Remove the code action quickfix.suppressRule.
The code action quickfix.suppressRule was removed in favour of two new code actions:
quickfix.suppressRule.inline.biome: a code action that adds a suppression comment for each violation.quickfix.suppressRule.topLevel.biome: a code action that adds a suppression comment at the top of the file which suppresses a rule for the whole file.Given the following code
let foo = "one";
debugger;
The code action quickfix.suppressRule.inline.biome will result in the following code:
// biome-ignore lint/style/useConst: <explanation>
let foo = "one";
// biome-ignore lint/suspicious/noDebugger: <explanation>
debugger;
The code action quickfix.suppressRule.topLevel.biome, instead, will result in the following code:
/** biome-ignore lint/suspicious/noDebugger: <explanation> */
/** biome-ignore lint/style/useConst: <explanation> */
let foo = "one";
debugger;
Changed default formatting of package.json.
When Biome encounters a file called
package.json, by default it will format the file with all objects and arrays expanded.
- { "name": "project", "dependencies": { "foo": "latest" } }
+ {
+ "projectName": "project",
+ "dependencies": {
+ "foo": "^1.0.0"
+ }
+ }
The organizeImports is now part of Biome Assist.
The rule noVar now belongs to the suspicious group
The rule useWhile now belongs to the complexity group.
The rule useImportExtensions has been updated to suggest actual file extensions instead of guesses based on heuristics.
As part of this, the suggestedExtensions option has been removed. A simpler, new option called
forceJsExtensions has been introduced for those who use
tsc's "module": "node16" setting.
The rule also no longer reports diagnostics to add an extension when the path doesn't exist at all, with or without extension.
Fixed #4545: useNamingConvention now correctly ignores declarations inside TypeScript's external modules.
The following interface name is no longer reported by the rule:
declare module "myExternalModule" {
export interface my_INTERFACE {}
}
The rule useAltText no longer checks the element's attributes containing object spread.
The following code doesn't trigger the rule anymore:
<img src="test.png" alt={alt} {...restProps}></img>
The rule useNamingConvention no longer accepts non-ASCII characters by default.
Prior to Biome 2.0, non-ASCII names were accepted by default. They are now rejected.
For example, the following code is now reported as invalid by the useNamingConvention rule.
let johnCafé;
If you want to allow non ASCII filenames and non-ASCII identifiers, you need to set the
requireAscii options in your Biome configuration file to false:
{
"linter": {
"rules": {
"style": {
"useFilenamingConvention": {
"level": "on",
"options": {
"requireAscii": false
}
}
"useFilenamingConvention": {
"level": "on",
"options": {
"requireAscii": false
}
}
}
}
}
}
Renamed the rule noUnnecessaryContinue to noUselessContinue. Run the command
biome migrate to update your configuration.
Renamed the rule noMultipleSpacesInRegularExpressionLiterals to noAdjacentSpacesInRegex. Run the command
biome migrate to update your configuration.
An option called allowNoReferrer has been added to the
noBlankTarget rule.
By default, noBlankTarget accepts both rel="noopener" and rel="noreferrer"
with links that have target="_blank". This is because the latter
implies the former, so either one is sufficient to mitigate the security risk.
However, allowing
rel="noreferrer" may still be undesirable, because it can break tracking, which may be an undesirable side-effect. As such, you can set
allowNoReferrer: false to only accept rel="noopener".
Added new option
javascript.parser.jsxEverywhere. This new option allows to control whether Biome should expect JSX syntax in .js/
.mjs/.cjs files.
When jsxEverywhere is set to false, having JSX syntax like <div></div> inside .js/.mjs/
.cjs files will result in a parsing error.
Despite the name of the option, JSX is never supported inside
.ts files. This is because TypeScript generics syntax may conflict with JSX in such files.
This option defaults to true.
Add a new JS assist rule -
useSortedKeys which enforces ordering of a JS object properties. This rule will consider spread/calculated keys e.g
[k]: 1 as non-sortable. Instead, whenever it encounters a non-sortable key, it will sort all the previous sortable keys up until the nearest non-sortable key, if one exist. This prevents breaking the override of certain keys using spread keys.
Source: https://perfectionist.dev/rules/sort-objects
// Base
// from
const obj = {
b: 1,
a: 1,
...g,
ba: 2,
ab: 1,
set aab(v) {
this._aab = v;
},
[getProp()]: 2,
aba: 2,
abc: 3,
abb: 3,
get aaa() {
return "";
},
};
// to
const obj = {
a: 1,
b: 1,
...g,
set aab(v) {
this._aab = v;
},
ab: 1,
ba: 2,
[getProp()]: 2,
get aaa() {
return "";
},
aba: 2,
abb: 3,
abc: 3,
};
Added the new rule noFloatingPromises.
Added the new rule noImportCycles.
Added the new rule noTsIgnore.
Added the new rule noUnwantedPolyfillio.
Added a format option
expand for Javascript and JSON formatters. The option allows to enforce the formatting of arrays and objects on multiple lines, regardless of their length. It has three options:
When set to
auto (default), objects are expanded if the first property has a leading newline. Arrays are collapsed when they fit to a single line. For example, both styles below are considered as already formatted:
const obj = {
foo: "bar",
};
const obj = { foo: "bar" };
When set to always, objects and arrays are always expanded.
When set to
never, objects and arrays are never expanded when they fit in a single line. It is equivalent to Prettier's Object Wrap option with
collapse.
The nursery rule noUnresolvedImports has been added.
Importing a non-existing export is an error at runtime or build time. With this rule, Biome can detect such incorrect imports and report errors for them.
Note that if you use TypeScript, you probably don't want to use this rule, since TypeScript already performs such checks for you.
The rule noFocusedTests can now detect the usage of focused tests inside loops.
// invalid
describe.only.each([["a"], ["b"]])("%s", (a) => {});
it.only.each([["a"], ["b"]])("%s", (a) => {});
test.only.each([["a"], ["b"]])("%s", (a) => {});
// valid
describe.each([["a"], ["b"]])("%s", (a) => {});
it.each([["a"], ["b"]])("%s", (a) => {});
test.each([["a"], ["b"]])("%s", (a) => {});
Linter groups now accept new options to enable/disable all rules that belong to a group, and control the severity of the rules that belong to those groups.
For example, you can downgrade the severity of rules that belong to "style" to emit "info" diagnostics:
{
"linter": {
"rules": {
"style": "info"
}
}
}
You can also enable all rules that belong to a group using the default severity of the rule using the "on" option:
{
"linter": {
"rules": {
"complexity": "on"
}
}
}
Biome assist is a new feature of the Biome analyzer. The assist is meant to provide **actions **. Actions differ from linter rules in that they aren't meant to signal errors.
The assist will provide code actions that users can opt into via configuration or via IDEs/editors, using the Language Server Protocol.
The assist is enabled by default. However, you can turn if off via configuration:
{
"assist": {
"enabled": false
}
}
You can turn on the actions that you want to use in your configuration. For example, you can enable the
useSortedKeys action like this:
{
"assist": {
"actions": {
"source": {
"useSortedKeys": "on"
}
}
}
}
Alternatively, IDE/editor users can decide which action to apply on save directly from the editor settings, as long as the assist is enabled.
For example, in VS Code you can apply the useSortedKeys action when saving a file by adding the following snippet in
settings.json:
{
"editor.codeActionsOnSave": {
"source.biome.useSortedKeys": "explicit"
}
}
In Zed, you can achieve the same by adding the following snippet in ~/.config/zed/settings.json:
{
"code_actions_on_format": {
"source.biome.useSortedKeys": true
}
}
Biome migrate eslint outputs a better overriding behavior.
A Biome rule can have multiple ESLint equivalent rules. For example, useLiteralKeys has two ESLint equivalent rules: dot-notation and @typescript-eslint/dot-notation.
Previously, Biome wouldn't always enable a Biome rule even if one of its equivalent rules was enabled. Now Biome uses the higher severity level of all the equivalent ESLint rules to set the severity level of the Biome rule.
The following ESLint configuration...
{
"rules": {
"@typescript-eslint/dot-notation": "error",
"dot-notation": "off"
}
}
...is now migrated to...
{
"linter": {
"rules": {
"complexity": {
"useLiteralKeys": "error"
}
}
}
}
...because error is higher than off.
Add useSymbolDescription.
Enhanced the command
migrate eslint. Now the command shows which ESLint rules were migrated, and which rules aren't supported yet.
./eslint.config.js migrate ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ℹ 42% (3/7) of the rules have been migrated.
ℹ Migrated rules:
- getter-return
- prefer-const
- @typescript-eslint/require-await
ℹ Rules that can be migrated to an inspired rule using --include-inspired:
- @typescript-eslint/parameter-properties
ℹ Rules that can be migrated to a nursery rule using --include-nursery:
- @typescript-eslint/switch-exhaustiveness-check
ℹ Stylistic rules that the formatter may support (manual migration required):
- semi
ℹ Unsupported rules:
- block-scoped-var
configuration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ℹ Migration results:
- ./biome.json: configuration successfully migrated.
Suppression of syntax rules
Added support for suppressing syntax rules. Syntax rules are particular rules meant **to complement the parser **, hence they can't be configured.
Biome now allows to suppress those rules. This can, for example, be useful in case the rule is affected by a bug. However, this is more an escape hatch, so if a syntax rule requires a suppression, please file an issue.
Example:
// biome-ignore syntax/correctness/noTypeOnlyImportAttributes: bug
import type { MyType } from "my-esm-pkg" with { "resolution-mode": "import" };
Biome now requires all biome-ignore-start suppressions to have an equivalent biome-ignore-end comment.
Add a new lint rule
noConstantBinaryExpression. This rule is inspired from ESLint's no-constant-binary-expression rule.
The CLI options --only and --skip now accept rule and action names without prefixing the group name.
Previously --only=noDebugger was rejected. You had to add the group name: --only=suspicious/noDebugger.
Fixed #3574:
noUnusedImports now reports empty named imports and suggests their removal.
The rule now suggests the removal of empty named imports such as:
- import {} from "mod";
Added the new rule useAdjacentGetterSetter, which enforces getters and setters for the same property to be adjacent in class and object definitions.
Example (Invalid): Name getter and setter are not adjacent:
class User {
get name() {
return this._name;
}
constructor() {}
set name(value) {
this._name = value;
}
}
**Example (Invalid): Getter should go before the setter.
const user = {
set name(value) {
this._name = value;
},
get name() {
return this._name;
},
};
Example (Valid): Name getter and setter are adjacent:
class User {
get name() {
return this._name;
}
set name(value) {
this._name = value;
}
get age() {
return this._age;
}
set age(age) {
this._age = age;
}
}
Added new rule useConsistentResponse which suggests to use static Response.json() and Response.redirect() methods instead of
new Response when possible.
Example:
new Response(JSON.stringify({ value: 1 }));
Response.json({ value: 1 });
Biome users can now configure code actions from linter rules as well as assist actions directly in the settings of their IDE/editor.
For example, let's consider the lint rule noSwitchDeclarations, which has an unsafe fix. Previously, if you wanted to use this rule, you were "forced" to enable it via configuration, and if you wanted to apply its fix when you saved a file, you were forced to mark the fix as safe:
{
"linter": {
"rules": {
"correctness": {
"noSwitchDeclarations": {
"level": "error",
"fix": "safe"
}
}
}
}
}
Now, you can benefit from the code action without making the fix safe for the entire project. IDEs and editors that are LSP compatible allow to list a series of "filters" or code actions that can be applied on save. In the case of VS Code, you will need to add the following snippet in the
settings.json:
{
"editor.codeActionsOnSave": {
"quickfix.biome.correctness.noSwitchDeclarations": "explicit"
}
}
Upon save, Biome will inform the editor the apply the code action of the rule noSwitchDeclarations.
Fixed #3401:
noUnusedImports now keeps comments separated from the import with a blank line.
For example:
// Orphan comment
- // Header comment
- import {} from "mod";
Added a new propertyAssignment option to the
noParameterAssign rule. This option allows to configure whether property assignments on function parameters are permitted. By default,
propertyAssignment is set to allow. Setting it to
deny enforces stricter immutability by disallowing property mutations on function parameters.
The formatter option bracketSpacing is now also supported in JSON files.
useValidTypeof now accepts comparisons with variables.
Previously, the rule required to compare a typeof expression against another
typeof expression or a valid string literal. We now accept more cases, notably comparison against a variable:
if (typeof foo === bar) {
// ...
}
Added the new rule noNestedComponentDefinitions, which disallows nested component definitions in React components.
This rule is useful for preventing potential performance issues and improving code readability by ensuring that components are defined at the top level.
Example (Invalid):
function ParentComponent() {
function ChildComponent() {
return <div>Hello</div>;
}
return <ChildComponent />;
}
Example (Valid):
function ChildComponent() {
return <div>Hello</div>;
}
function ParentComponent() {
return <ChildComponent />;
}
Added the new rule noDestructuredProps, which disallow the use of destructured props in Solid projects.
You can now enable lint rules using the default severity suggested by Biome using the new variant
"on", when enabling a rule.
For example, the default severity of the rule style.noVar is error, so you would use
"on", and then linting a code that uses var, will result in an error:
{
"linter": {
"recommended": false,
"rules": {
"style": {
"noVar": "on"
}
}
}
}
// main.js
var name = "tobias";
The command biome lint main.js will result in an error due to the default severity assigned to noVar.
Refer to the documentation page of each rule to know their suggested diagnostic severity, or use the command
biome explain <RULE_NAME>:
biome explain noVar
Biome VCS integration now supports nested ignore files.
For git, if a .gitignore is found in a nested folder root/packages/foo/, and it contains the pattern
dist/, only files and directories inside root/packages/foo/dist are matched.
Added the rule useUniqueElementIds. This rule disallows the use of static IDs in React components. It encourages to generate unique IDs for accessibility purposes using useId.
The following code is now reported as invalid:
function App() {
return <div id="static-id" />;
}
The following code is now reported as valid:
import { useId } from "react";
function App() {
const id = useId();
return <div id={id} />;
}
Added the new JavaScript rule useConsistentObjectDefinition rule. The rule enforces a consistent style for the definition of objects:
By default, the rule enforces a shorthand style:
const validShorthand = {
// Property shorthand
foo,
// Method shorthand
method() {
return "method";
},
};
Alternatively, the rule can be configured to enforce an explicit style:
const invalidExplicit = {
// Basic property shorthand violations
foo: foo,
// Method shorthand violations
method: function () {
return "method";
},
};
Introduced more advanced logging capabilities:
Every Biome CLI command can now be passed a
--log-file=<path> argument, which will write all log messages for that invocation to the given path instead of
stdout.
In addition, the --log-level parameter now also accepts a tracing value. When
--log-level=tracing is used, Biome also prints timing information from tracing spans to the log.
Combined with Biome's ability to print logs in JSON format, and the
jq command line utility, this allows you to perform advanced analysis on Biome's internal performance.
For example, if you want to figure out which paths take the longest when building the module graph, you can use the following commands:
biome lint --log-level=tracing --log-kind=json --log-file=tracing.json
cat tracing.json | jq '. | select(.span.name == "update_module_graph") | { path: .span.path, time_busy: .["time.busy"], time_idle: .["time.idle"] }' > filtered.json
Now you will have a file called
filtered.json with all the relevant timings, together with the paths used during the invocations.
Added options to suspicious/noConfusingLabels to allow specific labels.
Fixed #4549: noUnknownProperty now accepts more known CSS properties.
- ['anchor-default', 'anchor-scroll', 'inset-area', 'position-animation', 'position-fallback', 'position-fallback-bounds', 'position-try-options']
+ ['anchor-scope', 'interpolate-size', 'line-fit-edge', 'masonry', 'masonry-auto-tracks', 'masonry-direction', 'masonry-fill', 'masonry-flow', 'masonry-slack', 'masonry-template-areas', 'masonry-template-tracks', 'position-anchor', 'position-area', 'position-try-fallbacks', 'position-visibility', 'scroll-start-target', 'text-box', 'view-transition-class', 'view-transition-group']
This change replaces deprecated properties, improving CSS validation.
LSP clients can now override the configuration path for each workspace, by responding to
workspace/configuration requests.
Added the new CSS rule noImportantStyles, which prevents the use of
!important inside CSS declarations.
Biome now emits a warning diagnostic if the configuration contains an out-of-sync schema URL.
Introduced a new configuration setting files.experimentalScannerIgnores.
This setting may be used to configure a set of file and folder names that should be unconditionally ignored by Biome's scanner.
Biome maintains an internal list of default ignore entries, which is based on user feedback and which may change in any release. This setting allows overriding this internal list completely.
This is considered an advanced feature that users should not need to tweak themselves, but they can as a last resort. This setting can only be configured in root configurations, and is ignored in nested configs.
Entries must be file or folder names. Specific paths and globs are not supported.
Examples where this may be useful:
{
"files": {
"experimentalScannerIgnores": [
// You almost certainly don't want to scan your `.git` folder, which
// is why it's already ignored by default:
".git",
// But the scanner does scan `node_modules` by default. If you
// *really* don't want this, you can ignore it like this:
"node_modules",
// But it's probably better to ignore a specific dependency.
// For instance, one that happens to be particularly slow to scan:
"RedisCommander.d.ts",
],
},
}
Please be aware that rules relying on the module graph or type inference information may be negatively affected if dependencies of your project aren't (fully) scanned.
Added the new rule useSingleJsDocAsterisk which enforces JSDoc comment lines to start with a single asterisk.
// Invalid
/**
** Description
*/
// Valid
/**
* Description
*/
The CLI flag --javascript-attribute-position was renamed to
--javascript-formatter-attribute-position for consistency.
Introduced the domains linter feature. The Biome linter now has a new way to opt-in rules, with a concept called
domains.
Domains can be seen as concepts shared by different rules.
You can enable and disable multiple rules that belong to a domain. When you assign
"all", Biome will enable all the rules, when you assign
"none", Biome will disable the rules, when you assign "recommended", Biome will enable all rules of the domain that are recommended.
// biome.jsonc
{
linter: {
domains: {
test: "all", // all rules that belong to this domain are enabled
react: "recommended", // only the recommended rules from this domain are enabled
solid: "none", // rules related to Solid are disabled
},
},
}
New domains introduced:
test: it will enable rules:
noExportsInTestnoExcessiveNestedTestSuitesnoDuplicateTestHooksnoFocusedTests
And it will inject the following globals:afterafterAllafterEachbeforebeforeEachbeforeAlldescribeitexpecttestnext: it will enable rules for Next.js projects:
useExhaustiveDependenciesuseHookAtTopLevelnoImgElementnoHeadImportInDocumentnoHeadImportInDocumentreact: it will enable rules for React projects:
useExhaustiveDependenciesuseHookAtTopLevelsolid: it will enable rules for Solid projects:
noReactSpecificPropsFor more information regarding how Biome enables rules via domains, please refer to the documentation page of each rule.
Biome now prints diagnostics sorted by their severity. The order is the following:
This means that error diagnostics are printed last, so users can see them first.
Added the new rule useIterableCallbackReturn, which enforces consistent return values in iterable callbacks.
The following methods require a return value in their callback:
everyfilterfindfindIndexfindLastfindLastIndexflatMapmapreducereduceRightsomesorttoSorted
— from (when called on Array)The rule disallows a return value inside the callback of the method forEach.
Examples:
[].map(() => {
// Missing return value
});
[].forEach(() => {
return 1; // Disallowed
});
Added the new rule noReactPropAssign, based on the react-hooks rule react-hooks/react-compiler
The following code is now reported as invalid:
function Foo(props) {
props.bar = `Hello ${props.bar}`;
return <div>{props.bar}</div>;
}
The following code is now reported as valid:
function Foo({ bar }) {
bar = `Hello ${bar}`;
return <div>{bar}</div>;
}
Added new rule noBitwiseOperators, which disallows bitwise operators.
The Biome analyzer now supports a new top-level suppression. These suppression have to be placed at the top of the file, and they must be followed by two newlines (
\n\n\).
The analyzer rules specified inside the block comment will be suppressed for the whole file.
In the example, we suppress the rules lint/style/useConst and lint/suspicious/noDebugger for the whole file:
// main.js
/**
* biome-ignore-all lint/style/useConst: i like let
* biome-ignore-all lint/suspicious/noDebugger: needed now
*/
let path = "/path";
let _tmp = undefined;
debugger;
In this other example, we suppress lint/suspicious/noEmptyBlock for a whole CSS file:
/**
/* biome-ignore-all lint/suspicious/noEmptyBlock: it's fine to have empty blocks
*/
a {
}
span {
}
A new diagnostic is emitted if biome-ignore-all suppression isn't placed at the top of the file:
file.js:3:1 suppressions/incorrect ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
! Top level suppressions can only be used at the beginning of the file.
2 │ let foo = 2;
> 3 │ /**
│ ^^^
> 4 │ * biome-ignore-all lint/style/useConst: reason
> 5 │ */
│ ^^
6 │ let bar = 33;
i Rename this to biome-ignore
2 │ let foo = 2;
3 │ /**
> 4 │ * biome-ignore-all lint/style/useConst: reason
│ ^^^^^^^^^^^^^^^^
5 │ */
6 │ let bar = 33;
Added the new rule useNumericSeparators, which encourages the use of numeric separators to improve readability.
useImportExtensions now checks imports with sub extensions.
- import 'styles.css'
+ import 'styles.css.ts'
It's possible to override the option
files.maxSize. This option is helpful if you need to process specific files that exceed the default maxSize:
{
"overrides": [{
"includes": ["dist/**"]
"files": {
"maxSize": 20000
}
}]
}
Added the new CLI option called --threads to the
ci command. It allows to control the numbers of threads that can be used when using the Biome CLI.
It's possible to use the environment variable BIOME_THREADS as an alternatives.
This feature is useful when running the CLI in environments that have limited resources, for example CI/CD.
biome ci --threads=1
BIOME_THREADS=1 biome ci
Added the new rule useObjectSpread, which prefers object spread syntax over
Object.assign() when constructing new objects.
Example (Invalid): Using Object.assign with an empty object:
Object.assign({}, foo);
Object.assign({}, { foo: "bar" });
Example (Invalid): Using Object.assign with object literal as first argument:
Object.assign({ foo: "bar" }, baz);
Object.assign({}, baz, { foo: "bar" });
Example (Valid): Using object spread syntax:
({ ...foo });
({ ...baz, foo: "bar" });
Example (Valid): Modifying existing objects is allowed:
Object.assign(foo, { bar: baz });
Object.assign(foo, bar, baz);
Added an option to the lint command called
--suppress. The new option suppresses a violation instead of applying a rule fix. The option accepts a string that is used as
reason of the suppression comment.
When running the following command, it will add the suppression comment:
biome lint --write --suppress="Migration to Biome"
debugger;
foo == bar;
+ // biome-ignore lint/suspicious/noDebugger: Migration to Biome
debugger;
+ // biome-ignore lint/suspicious/noDoubleEquals: Migration to Biome
foo == bar;
Add an ignoreRestSiblings option into noUnusedVariables.
When this option is set to false, the rule will not ignore variables that created using the rest pattern:
{
"linter": {
"rules": {
"correctness": {
"noUnusedVariables": {
"level": "error",
"options": {
"ignoreRestSiblings": false
}
}
}
}
}
}
const { lorem, ...test } = bar; // the variable "test" will trigger the rule
console.log(lorem);
Upgraded some unsafe fixes to safe fixes.
The following rules have now a safe fix:
Added support for monorepos. The feature will work out of the box for the majority of the users. If your project has
nested configuration files, use the command biome migrate from the root of the project.
Monorepo support in Biome is done in a single way. Create a
biome.json at the root of the project. This configuration file is now called the root configuration. Then, each nested configuration file must specify the new field
"root": false.
We also introduced a new microsyntax for extending a nested configuration from the root configuration, which is
"extends": "//". This new syntax means “this config
extends from the root config”. When using this microsyntax, you may omit the
"root": false field as it is implied.
Note that nested configs are not required to extend from the root config, and you can still have independent nested configs, as well as nested configs that extend from other files. In those cases,
"root": false must be specified explicitly.
Added support for formatting .html files. The formatting is considered **experimental,
** and it's only opt-in via configuration:
{
"html": {
"formatter": {
"enabled": true
}Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Your coding agent can read these notes before it upgrades. Set up the MCP server →