Linter (oxlint)

Overview

Oxlint is a production-ready linter that catches mistakes in your JavaScript and TypeScript code. It’s designed to be 50-100x faster than ESLint while maintaining compatibility with ESLint’s configuration format and rules.

Lightning Fast

Lints 4800+ files in under 1 second. Built for monorepos and large codebases.

ESLint Compatible

Drop-in replacement supporting popular ESLint plugins and configurations.

200+ Rules

Comprehensive rule coverage including TypeScript, React, and more.

Auto-fixing

Automatically fix many issues with --fix flag.

Quick Start

Run without installation

npx oxlint@latest

Oxlint will automatically discover and lint all JavaScript/TypeScript files in your project.

Install locally

npm install -D oxlint

Then add to your package.json:

package.json

{
  "scripts": {
    "lint": "oxlint"
  }
}

CLI Usage

Basic Commands

# Lint current directory
oxlint

# Lint specific files or directories
oxlint src/ lib/ index.js

# Auto-fix issues
oxlint --fix

# Check with specific configuration
oxlint -c .oxlintrc.json

CLI Options

Flag	Description
`-c, --config <PATH>`	Path to configuration file (`.oxlintrc.json`, `.oxlintrc.jsonc`, or `oxlint.config.ts`)
`--init`	Initialize oxlint configuration with default values
`--tsconfig <PATH>`	Path to TypeScript config for import plugin and path aliases

Flag	Description
`-A, --allow <NAME>`	Allow/suppress a rule or category
`-W, --warn <NAME>`	Warn on a rule or category
`-D, --deny <NAME>`	Deny/error on a rule or category
`--rules`	List all available rules

Rule Categories:

correctness - Code that is outright wrong or useless (default)
suspicious - Code that is most likely wrong or useless
pedantic - Strict lints with occasional false positives
perf - Performance improvements
style - Idiomatic code style
restriction - Prevent use of language/library features
nursery - New lints under development
all - All categories except nursery

Flag	Description
`--fix`	Fix as many issues as possible
`--fix-suggestions`	Apply auto-fixable suggestions (may change behavior)
`--fix-dangerously`	Apply dangerous fixes and suggestions

Flag	Description
`-f, --format <FORMAT>`	Output format: `default`, `stylish`, `json`, `unix`, `checkstyle`, `github`, `gitlab`, `junit`
`--quiet`	Disable warnings, only show errors
`--deny-warnings`	Ensure warnings produce non-zero exit code
`--max-warnings <INT>`	Exit with error if warnings exceed threshold

Flag	Description
`--import-plugin`	Enable import plugin (ESM problems)
`--react-plugin`	Enable React plugin
`--jsdoc-plugin`	Enable JSDoc plugin
`--jest-plugin`	Enable Jest plugin
`--vitest-plugin`	Enable Vitest plugin
`--jsx-a11y-plugin`	Enable JSX accessibility plugin
`--nextjs-plugin`	Enable Next.js plugin
`--react-perf-plugin`	Enable React performance plugin
`--promise-plugin`	Enable promise plugin
`--node-plugin`	Enable Node.js plugin
`--vue-plugin`	Enable Vue plugin
`--disable-typescript-plugin`	Disable TypeScript plugin (on by default)
`--disable-unicorn-plugin`	Disable unicorn plugin (on by default)
`--disable-oxc-plugin`	Disable oxc unique rules (on by default)

Flag	Description
`--threads <NUM>`	Number of threads to use
`--type-aware`	Enable rules requiring type information
`--type-check`	Enable experimental TypeScript compiler diagnostics
`--disable-nested-config`	Disable automatic loading of nested configs
`--lsp`	Start language server protocol server
`--report-unused-disable-directives`	Report when disable directives have no effect

Examples

# Deny all warnings and errors in the correctness category
oxlint -D correctness

# Allow no-debugger and deny no-console
oxlint -A no-debugger -D no-console

# Deny all rules, then allow specific ones
oxlint -D all -A no-unused-vars -A no-console

# Lint with type-aware rules
oxlint --type-aware --tsconfig ./tsconfig.json

# Format output for GitHub Actions
oxlint --format github

# Lint with React and Jest plugins
oxlint --react-plugin --jest-plugin

Configuration

Configuration File

Create .oxlintrc.json in your project root:

.oxlintrc.json

{
  "$schema": "./node_modules/oxlint/configuration_schema.json",
  "plugins": [
    "typescript",
    "react",
    "unicorn",
    "import",
    "jsdoc"
  ],
  "categories": {
    "correctness": "error",
    "suspicious": "warn",
    "perf": "error"
  },
  "rules": {
    "no-console": "error",
    "no-debugger": "error",
    "prefer-const": ["error", { "destructuring": "all" }],
    "typescript/no-explicit-any": "warn",
    "react/jsx-key": "error"
  },
  "ignorePatterns": [
    "**/node_modules/**",
    "**/dist/**",
    "**/*.min.js"
  ]
}

Rule Configuration

Rules can be configured with severity levels and options:

{
  "rules": {
    "no-unused-vars": "off",      // Disable rule
    "no-console": "warn",         // Warning
    "no-debugger": "error"        // Error
  }
}

Overrides

Apply different rules to specific files:

.oxlintrc.json

{
  "rules": {
    "no-console": "error"
  },
  "overrides": [
    {
      "files": ["test/**/*.test.ts"],
      "rules": {
        "no-console": "off"
      }
    },
    {
      "files": ["**/*.config.js"],
      "rules": {
        "no-restricted-imports": ["error", {
          "patterns": [{
            "regex": ".*/dist/.*",
            "message": "Don't import from dist"
          }]
        }]
      }
    }
  ]
}

Ignore Patterns

Oxlint respects .gitignore by default. Additional patterns:

Configuration File
.oxlintignore File
CLI Flag

.oxlintrc.json

{
  "ignorePatterns": [
    "**/fixtures/**",
    "**/generated/**",
    "**/*.min.js",
    "!important-file.js"  // Negation
  ]
}

.oxlintignore

# Build outputs
dist/
build/

# Dependencies
node_modules/

# Generated files
**/*.generated.ts

# Keep specific file
!src/important.js

oxlint --ignore-path .gitignore --ignore-path .eslintignore

Available Rules

View All Rules

oxlint --rules

Major Rule Collections

ESLint Core Rules

no-unused-vars - Disallow unused variables
no-console - Disallow console statements
no-debugger - Disallow debugger statements
prefer-const - Prefer const over let
no-var - Disallow var declarations
curly - Enforce consistent brace style
And 100+ more…

TypeScript Rules

@typescript-eslint/no-explicit-any - Disallow any type
@typescript-eslint/no-unused-vars - TS-aware unused variables
@typescript-eslint/ban-ts-comment - Ban @ts- comments
@typescript-eslint/consistent-type-imports - Consistent imports
And 50+ more…

React Rules

react/jsx-key - Enforce key prop in iterators
react/no-array-index-key - Prevent array index as key
react/jsx-no-duplicate-props - No duplicate props
react-hooks/rules-of-hooks - Enforce hooks rules
react-hooks/exhaustive-deps - Check effect dependencies

Import Rules

import/no-cycle - Detect circular dependencies
import/no-duplicates - No duplicate imports
import/extensions - Enforce file extensions
import/no-self-import - Prevent self-imports

Unicorn Rules

unicorn/filename-case - Enforce filename conventions
unicorn/no-null - Disallow null
unicorn/prefer-module - Prefer ES modules
unicorn/no-array-for-each - Prefer for-of

Performance

Benchmarks

On a typical codebase (VS Code repository with 4800+ files):

Tool	Time
oxlint	0.7s
ESLint	60s+

Oxlint is approximately 50-100x faster than ESLint on large codebases.

Performance Features

Single AST pass: Most rules run in one traversal
Parallel processing: Multi-threaded file processing
Arena allocation: Efficient memory management
Optimized parsing: Leverages oxc’s fast parser

Language Server Protocol (LSP)

Oxlint includes a built-in language server for editor integration:

# Start LSP server
oxlint --lsp

Editor Integration

VS Code
Neovim
Other Editors

Install the oxc VS Code extension for:

Real-time linting
Quick fixes
Rule documentation on hover

require('lspconfig').oxc_language_server.setup({
  cmd = { 'oxlint', '--lsp' },
  filetypes = { 'javascript', 'javascriptreact', 'typescript', 'typescriptreact' },
  root_dir = require('lspconfig.util').root_pattern('package.json', '.git'),
})

Configure your LSP client to run oxlint --lsp for JavaScript/TypeScript files.

Migration from ESLint

Compatibility

Oxlint is designed for easy migration:

Config format: Supports ESLint-style configuration
Rule names: Uses the same rule names as ESLint
Plugins: Compatible with major ESLint plugins
Output formats: Supports ESLint output formats

Migration Steps

Install oxlint

npm install -D oxlint

Initialize configuration

npx oxlint --init

This creates .oxlintrc.json based on your project.

Test alongside ESLint

package.json

{
  "scripts": {
    "lint:eslint": "eslint .",
    "lint:oxlint": "oxlint",
    "lint": "oxlint"  // Switch when ready
  }
}

Gradually migrate rules

Start with core rules, then enable plugins as needed.

Some ESLint rules may have slight behavioral differences. Test thoroughly before full migration.

CI/CD Integration

GitHub Actions

.github/workflows/lint.yml

name: Lint

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npx oxlint --format github

GitLab CI

.gitlab-ci.yml

lint:
  image: node:20
  script:
    - npm ci
    - npx oxlint --format gitlab
  artifacts:
    reports:
      codequality: gl-code-quality-report.json

Pre-commit Hook

package.json

{
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": "oxlint --fix"
  }
}

API Reference

For programmatic usage from Node.js or Rust, see:

CLI Reference

Complete CLI command reference

Rust API

Build tools with oxc_linter crate

FAQ

Why is oxlint so much faster than ESLint?

Oxlint is written in Rust with performance as a primary goal. It uses:

A highly optimized parser (oxc_parser)
Arena allocation for memory efficiency
Single-pass AST traversal for most rules
Parallel file processing
No plugin loading overhead

Does oxlint support all ESLint rules?

Oxlint implements the most commonly used ESLint rules and major plugins. Check oxlint --rules for the complete list. If you need a specific rule, please open an issue on GitHub.

Can I use oxlint with my existing ESLint config?

Partially. Oxlint uses a similar config format but with some differences. Use oxlint --init to generate a compatible config based on your project.

Does oxlint support custom plugins?

Currently, oxlint has built-in support for major plugins (TypeScript, React, etc.). External JavaScript-based plugins are not yet supported, but this is planned for future releases.

Can I use oxlint in monorepos?

Yes! Oxlint is designed for monorepos and large codebases. Use nested config files or the --disable-nested-config flag to control configuration resolution.

Resources

GitHub Repository

Source code and issue tracker

Rule Documentation

Complete rule reference

Discord Community

Get help and discuss features

npm Package

Install from npm

Getting Started

Architecture

Tools

Using Oxc

Core Concepts

​Overview

Lightning Fast

ESLint Compatible

200+ Rules

Auto-fixing

​Quick Start

​Run without installation

​Install locally

​CLI Usage

​Basic Commands

​CLI Options

​Examples

​Configuration

​Configuration File

​Rule Configuration

​Overrides

​Ignore Patterns

​Available Rules

​View All Rules

​Major Rule Collections

​Performance

​Benchmarks

​Performance Features

​Language Server Protocol (LSP)

​Editor Integration

​Migration from ESLint

​Compatibility

​Migration Steps

​CI/CD Integration

​GitHub Actions

​GitLab CI

​Pre-commit Hook

​API Reference

CLI Reference

Rust API

​FAQ

​Resources

GitHub Repository

Rule Documentation

Discord Community

npm Package

Build docs developers (and LLMs) love

Overview

Quick Start

Run without installation

Install locally

CLI Usage

Basic Commands

CLI Options

Examples

Configuration

Configuration File

Rule Configuration

Overrides

Ignore Patterns

Available Rules

View All Rules

Major Rule Collections

Performance

Benchmarks

Performance Features

Language Server Protocol (LSP)

Editor Integration

Migration from ESLint

Compatibility

Migration Steps

CI/CD Integration

GitHub Actions

GitLab CI

Pre-commit Hook

API Reference

FAQ

Resources