Skip to content
DoCodeHereDeveloper tools and services

Code editors and AI coding tools · Researched comparison

Best JavaScript Linters in 2026

ESLint is the first pick for most teams. It has the largest rule ecosystem and plugin support, and it fits projects of any size. Biome suits teams that want linting and formatting from one fast Rust-based tool with minimal configuration. oxlint is a good choice when lint speed on large codebases matters most, and it can run alongside ESLint during migration.

By · Published 21 Nov 2026

We run no ads and no affiliate links at launch. The order of a list follows our published method.

Prices are the starting prices vendors list publicly. Plans change, so confirm the current price on the vendor page before you buy.

Key takeaways

ToolBest forStandout featureListed starting priceFree plan or trial
1 ESLintTeams that need broad rule coverage and pluginsLargest rule and plugin ecosystemFree (open source)Free plan
2 BiomeTeams wanting one fast tool for lint and formatCombines linter and formatter in one binaryFree (open source)Free plan
3 oxlintLarge codebases where lint speed matters mostVery fast Rust-based linterFree (open source)Free plan
4 StandardJSSmall projects that want one fixed styleNo configuration neededFree (open source)Free plan
5 JSHintLegacy projects needing a simple configurable linterSimple configuration through options and inline commentsFree (open source)Free plan
6 quick-lint-jsFast error checking in editors while typingFast C++ implementation with low editor latencyFree (open source)Free plan

How we picked

We compared linters on fit for everyday JavaScript work, supported platforms and editors, licence and price, configuration effort, rule coverage and documented limits. Sources are official project sites, documentation and repositories. We did not run benchmarks or collect user reviews. Prices and licences can change, so confirm details on the vendor or project site before you commit.

01

ESLint

Best for: Teams that need broad rule coverage and plugins

ESLint parses JavaScript and reports problems based on a configurable set of rules. It runs on Node.js and works in editors through official and community extensions, in CI pipelines, and from the command line. The project moved to a flat config format (`eslint.config.js`), and older `.eslintrc` files need migration. TypeScript support comes through the typescript-eslint parser and plugin packages rather than a separate linter.

The core is MIT licensed and free. Rules ship in the core package, and framework or library rules come from community plugins. There is no paid tier. The main cost is setup time: large teams often need shared config packages to keep rules consistent across repositories. Skip ESLint if you want zero configuration or if lint time on a very large monorepo is a hard constraint and you have not yet tried a faster parser or a Rust-based alternative.

Pros

  • Largest rule and plugin ecosystem
  • supports JavaScript, TypeScript and JSX through configuration

Cons

  • Slower on very large codebases
  • flat config setup takes effort

Price: Free (open source), as listed by the vendor (ESLint website). Confirm the current plan price before you buy.

Skip it if this limit matters to you: slower on very large codebases.

Verdict. A sensible pick for teams that need broad rule coverage and plugins.

02

Biome

Best for: Teams wanting one fast tool for lint and format

Biome is a toolchain written in Rust that provides linting and formatting for JavaScript, TypeScript, JSX and JSON. It installs as a single binary or npm package and runs from the command line or an editor extension. Configuration lives in `biome.json`, and a migration command can convert an existing ESLint or Prettier setup.

The project is MIT licensed and free, with no paid tier. Its rule set covers common correctness and style checks but is smaller than ESLint's plugin ecosystem, so projects that depend on niche framework rules may need to keep ESLint for those cases. Biome suits teams that want fewer moving parts and fast runs. Skip it if you rely on ESLint plugins that have no Biome equivalent.

Pros

  • Combines linter and formatter in one binary
  • fast Rust implementation with low configuration overhead

Cons

  • Smaller rule set than ESLint
  • fewer framework-specific plugins

Price: Free (open source), as listed by the vendor (Biome website). Confirm the current plan price before you buy.

Skip it if this limit matters to you: smaller rule set than ESLint.

Verdict. A sensible pick for teams wanting one fast tool for lint and format.

03

oxlint

Best for: Large codebases where lint speed matters most

oxlint is part of the oxc project, a set of JavaScript tooling written in Rust. It focuses on fast linting and ships as an npm package and standalone binary. It supports JavaScript and TypeScript and includes a growing set of rules drawn from ESLint and other linters. The project documents which ESLint rules it covers and which are planned.

oxlint is MIT licensed and free. It is often used as a first, fast pass in CI, with ESLint kept for rules oxlint does not yet implement. Check the rule coverage list before replacing ESLint entirely, since gaps can let issues through. Skip oxlint if your project depends on custom ESLint plugins, which oxlint does not run.

Pros

  • Very fast Rust-based linter
  • can run alongside ESLint during migration

Cons

  • Fewer rules than ESLint
  • some rules are still being added

Price: Free (open source), as listed by the vendor (oxlint website). Confirm the current plan price before you buy.

Skip it if this limit matters to you: fewer rules than ESLint.

Verdict. A sensible pick for large codebases where lint speed matters most.

04

StandardJS

Best for: Small projects that want one fixed style

StandardJS is an ESLint-based linter with a fixed rule set and no configuration file. It enforces a specific style, including two-space indentation and no semicolons, and reports style and correctness problems together. It runs on Node.js from the command line and through editor plugins.

The package is MIT licensed and free. Because the rules cannot be changed, teams that disagree with any of the style choices have no way to adjust them, which is the main reason projects move to ESLint. StandardJS suits small projects, scripts and solo developers who want consistent output without config work. Skip it for teams with existing style guides or frameworks that expect different formatting.

Pros

  • No configuration needed
  • catches style and correctness issues in one pass

Cons

  • Rules are not configurable
  • style choices are fixed

Price: Free (open source), as listed by the vendor (StandardJS website). Confirm the current plan price before you buy.

Skip it if this limit matters to you: rules are not configurable.

Verdict. A sensible pick for small projects that want one fixed style.

05

JSHint

Best for: Legacy projects needing a simple configurable linter

JSHint is a community-maintained linter for JavaScript. It is configured with a `.jshintrc` file or inline comments, and it can run from the command line, in editors, or in a browser page on the project site. It reports syntax errors and suspicious patterns based on enabled options.

JSHint is MIT licensed and free. Its rule set is smaller than ESLint's and it has fewer integrations, so it is mostly found in older codebases that adopted it before ESLint became dominant. New projects are usually better served by ESLint or Biome. Keep JSHint if an existing project already depends on its specific options and migration cost is not justified.

Pros

  • Simple configuration through options and inline comments
  • runs in the browser and on Node.js

Cons

  • Smaller rule set than ESLint
  • fewer updates and plugins

Price: Free (open source), as listed by the vendor (JSHint website). Confirm the current plan price before you buy.

Skip it if this limit matters to you: smaller rule set than ESLint.

Verdict. A sensible pick for legacy projects needing a simple configurable linter.

06

quick-lint-js

Best for: Fast error checking in editors while typing

quick-lint-js is a linter written in C++ that targets fast feedback in editors. It reports syntax errors and use of undeclared variables, and it integrates with several editors through a language server. It runs on Windows, macOS and Linux from the command line or as an editor plugin.

The project is MIT licensed and free. It does not aim to replace a full style linter, so most teams run it alongside ESLint or Biome for immediate error feedback while typing. Skip it if you need style enforcement or framework-specific rules from a single tool.

Pros

  • Fast C++ implementation with low editor latency
  • reports syntax and undefined-variable errors

Cons

  • Focuses on errors rather than style rules
  • smaller rule set than ESLint

Price: Free (open source), as listed by the vendor (quick-lint-js website). Confirm the current plan price before you buy.

Skip it if this limit matters to you: focuses on errors rather than style rules.

Verdict. A sensible pick for fast error checking in editors while typing.

Who should use what

A team on a large existing codebase with many plugins should use ESLint. A new project that wants lint and format from one fast tool should use Biome. A monorepo where lint time is a bottleneck should try oxlint as a fast first pass. A solo developer or small script collection that wants no configuration should use StandardJS. A legacy project already on JSHint can stay there if migration is not worth the cost.

What to check before you buy

FAQ

Is ESLint still the best JavaScript linter?

ESLint remains the most widely used linter because of its rule and plugin ecosystem. It is free and open source. Faster Rust-based tools like Biome and oxlint are good alternatives, but they cover fewer rules, so check coverage before switching.

Are these linters free?

Yes. All six tools listed are free and open source under permissive licences. None require a paid licence for linting JavaScript. Costs come from setup and maintenance time, not licence fees.

Can I run two linters together?

Yes. A common pattern is oxlint or quick-lint-js for fast feedback plus ESLint for full rule coverage. Run them in sequence in CI and keep rule sets from overlapping too much to avoid duplicate reports.

Do these linters check TypeScript?

ESLint checks TypeScript through the typescript-eslint parser and plugin packages. Biome and oxlint support TypeScript directly. StandardJS, JSHint and quick-lint-js focus on JavaScript and have limited or no TypeScript support.

Do linters send my code anywhere?

These linters run locally on your machine or in your CI system and do not upload code by default. Check any editor extension or hosted service separately, and avoid pasting proprietary code into third-party web pages.

Sources we checked

  1. ESLint (official site)
  2. Biome (official site)
  3. oxlint (official site)
  4. StandardJS (official site)
  5. JSHint (official site)
  6. quick-lint-js (official site)

Change log. First published 21 Nov 2026.