Oxlint 1.0 Hits the Market: The Rust Linter That Promises to Be 100x Faster Than ESLint

Hello HaWkers, if you work with JavaScript or TypeScript, you've probably experienced the frustration of waiting for ESLint to analyze your code in large projects. Those seconds feel like hours, especially when you're in the flow of development.

What if I told you there's a new tool that promises to do the same job up to 100 times faster? It sounds like an exaggeration, but Oxlint 1.0, officially released in December 2025, is proving this is possible.

What Is Oxlint and Why Should You Care

Oxlint is a linter for JavaScript and TypeScript written entirely in Rust, developed by the Oxc (Oxidation Compiler) project team. Version 1.0 marks the tool's maturity, now featuring over 520 implemented rules and full support for production projects.

Impressive Numbers

Performance compared to ESLint:

Lint time on medium project: 50-100x faster
Memory consumption: 3-5x lower
Startup time: practically instantaneous

Rule coverage:

520+ rules implemented
Support for ESLint, TypeScript-ESLint, and popular plugins
Multi-file analysis to detect cross-module issues

How Oxlint Achieves This Performance

The fundamental difference lies in the implementation language. While ESLint is written in JavaScript and runs on Node.js, Oxlint is written in Rust, a compiled language known for its near C/C++ performance and memory safety.

Optimized Architecture

Oxlint uses advanced techniques to maximize speed:

// Conceptual example of Oxlint architecture
// Parallel parsing of multiple files

use rayon::prelude::*;

fn lint_project(files: Vec<PathBuf>) -> Vec<Diagnostic> {
    files
        .par_iter() // Parallel processing
        .flat_map(|file| {
            let source = read_file(file);
            let ast = parse_javascript(&source);
            run_lint_rules(&ast)
        })
        .collect()
}

The ability to process multiple files in parallel, combined with an extremely optimized AST parser, results in dramatic performance gains.

Oxlint performance comparison

Zero Configuration Required

One of Oxlint's great advantages is that it works immediately, without any configuration needed:

# Install Oxlint
npm install -D oxlint

# Run - works immediately
npx oxlint ./src

# Or with more details
npx oxlint ./src --format=pretty

Migrating From ESLint to Oxlint

If you already use ESLint, migration is surprisingly simple. Oxlint offers compatibility tools that make the transition easier.

Gradual Migration Strategy

You don't need to completely abandon ESLint all at once. The recommended approach is to use both during the transition:

{
  "scripts": {
    "lint": "oxlint ./src && eslint ./src --rule-filter=complex-rules",
    "lint:fast": "oxlint ./src",
    "lint:full": "eslint ./src"
  }
}

Custom Configuration

For projects that need specific configurations, Oxlint supports configuration files:

// oxlint.json
{
  "rules": {
    "no-unused-vars": "error",
    "no-console": "warn",
    "prefer-const": "error",
    "no-debugger": "error"
  },
  "ignore": [
    "node_modules",
    "dist",
    "*.test.js"
  ],
  "plugins": ["typescript", "react"]
}

Available Rules and Coverage

Oxlint 1.0 covers the vast majority of the most used rules in the ESLint ecosystem.

Supported Rule Categories

Core ESLint Rules:

best-practices: 85% coverage
errors: 95% coverage
es6: 90% coverage
variables: 88% coverage

TypeScript-ESLint:

78% of rules implemented
Type-aware linting support
Integration with tsconfig.json

Popular Plugins:

eslint-plugin-react: 82% coverage
eslint-plugin-import: 70% coverage
eslint-plugin-jsx-a11y: 65% coverage

Multi-File Analysis: An Important Differentiator

One of the most powerful features of Oxlint 1.0 is the ability to analyze relationships between files, something traditional ESLint does with limitations.

// utils/helper.js
export function calculateTotal(items) {
  return items.reduce((sum, item) => sum + item.price, 0);
}

// Function exported but never used anywhere
export function deprecatedHelper() {
  console.log('This function is no longer used');
}

// components/Cart.js
import { calculateTotal } from '../utils/helper';
// Note: deprecatedHelper was not imported

export function Cart({ items }) {
  const total = calculateTotal(items);
  return <div>Total: {total}</div>;
}

Oxlint can detect that deprecatedHelper was exported but never imported anywhere in the project, generating a dead code warning.

Integration with Editors and CI/CD

VS Code

The official Oxlint extension for VS Code offers real-time feedback:

// .vscode/settings.json
{
  "oxlint.enable": true,
  "oxlint.run": "onSave",
  "oxlint.autoFixOnSave": true,
  "eslint.enable": false
}

GitHub Actions

Integrating Oxlint into your CI pipeline is simple:

# .github/workflows/lint.yml
name: Lint

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm ci

      - name: Run Oxlint
        run: npx oxlint ./src --format=github

Direct Comparison: Oxlint vs ESLint

To help you decide, here's a detailed comparison:

Aspect	Oxlint 1.0	ESLint 9.x
Performance	50-100x faster	Baseline
Rules	520+	290+ core
Plugins	Growing	Mature ecosystem
Configuration	Zero-config	Requires setup
Type-aware	Supported	Via plugin
Auto-fix	Partial	Complete
Community	Growing	Established

When to Use Each One

Choose Oxlint if:

Performance is top priority
New or medium-sized project
Want configuration simplicity
Use industry-standard rules

Keep ESLint if:

Depend on specific unsupported plugins
Have very customized configurations
Need all auto-fixes

The Future of Linting in JavaScript

Oxlint represents a larger trend in the JavaScript ecosystem: rewriting critical tools in high-performance languages like Rust. We see this also in:

SWC: Rust compiler replacing Babel
Turbopack: Next.js Rust bundler
Biome: Rust formatter and linter (ex-Rome)
Rspack: Rust alternative to Webpack

💡 Trend: The JavaScript ecosystem is gradually adopting Rust for build tools, resulting in 10-100x performance gains.

Conclusion and Next Steps

Oxlint 1.0 isn't just another tool - it's a sign that the era of slow JavaScript tools is coming to an end. With 100x superior performance and impressive ease of use, it's worth testing on your next project.

If you're interested in high-performance JavaScript tools, I recommend checking out another article: Deno 2.6 Launches dx: The New npx That Promises to Revolutionize How We Run Packages where you'll discover how the JavaScript ecosystem is rapidly evolving.