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.
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
ESLint is free and open source under the MIT licence, and it remains the most widely supported linter for JavaScript and TypeScript.
Biome and oxlint are free, open source, Rust-based tools that run fast and need little setup.
StandardJS is free and enforces one fixed style with no configuration, which suits small projects but not teams with custom rules.
All six tools listed here are free or open source; none require a paid licence to lint JavaScript.
Tool
Best for
Standout feature
Listed starting price
Free plan or trial
1 ESLint
Teams that need broad rule coverage and plugins
Largest rule and plugin ecosystem
Free (open source)
Free plan
2 Biome
Teams wanting one fast tool for lint and format
Combines linter and formatter in one binary
Free (open source)
Free plan
3 oxlint
Large codebases where lint speed matters most
Very fast Rust-based linter
Free (open source)
Free plan
4 StandardJS
Small projects that want one fixed style
No configuration needed
Free (open source)
Free plan
5 JSHint
Legacy projects needing a simple configurable linter
Simple configuration through options and inline comments
Free (open source)
Free plan
6 quick-lint-js
Fast error checking in editors while typing
Fast C++ implementation with low editor latency
Free (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
Confirm the linter supports your language mix, including TypeScript and JSX if you use them.
Check that the rules you depend on exist, especially framework-specific ones from ESLint plugins.
Verify editor and CI integration for your team's tools.
Review the licence and whether any paid tier applies to your use.
Test run time on your largest repository before replacing an existing setup.
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.