Oxlint logo

Oxlint

基于 Rust 构建的超高性能 JavaScript/TypeScript Linter,比 ESLint 快 50-100 倍,Oxc 生态核心组件。

代码质量RustLinter高性能

Oxlint 是基于 Rust 构建的超高性能 JavaScript/TypeScript Linter,比 ESLint 快 50-100 倍,是 Oxc 编译工具链生态的核心 Linter 组件。

Oxlint

基于 Rust 构建的超高性能 JavaScript/TypeScript Linter,比 ESLint 快 50-100 倍,Oxc 生态核心组件。

技术简介说明

Oxlint 是 Oxc(The JavaScript Oxidation Compiler) 生态中的核心 Linter 工具,由 VoidZero 团队(Vite 核心维护者)使用 Rust 开发。它的设计目标是提供比 ESLint 快数十倍的代码质量检查能力,同时保持与 ESLint 生态的高度兼容性。

2025 年 6 月,Oxlint 发布了首个稳定版本 v1.0,标志着其正式进入生产可用阶段。截至 2026 年中,最新版本为 v1.71.0,已支持 800+ 条规则,并具备真正的类型感知(type-aware)Lint 能力。

基本信息

属性说明
名称Oxlint
仓库oxc-project/oxc
官网https://oxc.rs/
文档https://oxc.rs/docs/guide/usage/linter
最新版本v1.71.0(2026 年 6 月)
首个稳定版v1.0(2025 年 6 月)
开发语言Rust
开源协议MIT
规则数量800+
包管理npm(oxlint
支持平台Windows / macOS / Linux
Node.js 要求无强依赖(原生二进制),Node 仅用于 npm wrapper

快速上手

安装

# 使用 npm
npm install -D oxlint
 
# 使用 pnpm
pnpm add -D oxlint
 
# 使用 yarn
yarn add -D oxlint

基础配置

在项目根目录创建 oxlintrc.json

{
  "$schema": "./node_modules/oxlint/configuration_schema.json",
  "rules": {
    "no-debugger": "error",
    "no-console": "warn",
    "eqeqeq": ["error", "always"],
    "no-unused-vars": "warn"
  },
  "env": {
    "browser": true,
    "es2024": true,
    "node": true
  },
  "categories": {
    "correctness": "warn",
    "suspicious": "warn",
    "pedantic": "off",
    "restriction": "off",
    "nursery": "off"
  }
}

最小可运行示例

# 检查当前项目
npx oxlint
 
# 检查指定目录
npx oxlint src/
 
# 只检查特定文件类型
npx oxlint --ignore-pattern dist/ --ignore-pattern node_modules/ .
 
# 指定规则级别
npx oxlint --deny no-debugger --allow no-console

在 package.json 中集成

{
  "scripts": {
    "lint": "oxlint src/ --config oxlintrc.json",
    "lint:fix": "oxlint src/ --fix"
  }
}

核心概念与架构

Oxc 生态架构

Oxlint 是 Oxc 编译工具链的核心组件之一,整体架构如下:

┌─────────────────────────────────────────────────┐
│                  Oxc 生态                        │
├─────────────────────────────────────────────────┤
│  oxlint        — Linter(规则检查)              │
│  oxfmt         — Formatter(代码格式化)         │
│  oxc-parser    — 解析器(AST 生成)              │
│  oxc-transform — 转译器(TS → JS)              │
│  oxc-minifier  — 压缩器                         │
│  oxc-mangler   — 变量名混淆                     │
│  oxc-bundler   — 打包器(规划中)               │
└─────────────────────────────────────────────────┘
         ↑ 全部用 Rust 编写,零依赖外部解析器

Oxlint 内部架构

源代码输入
    │
    ▼
┌──────────────┐
│   解析器      │  oxc-parser(Rust,生成 AST)
│  (Parser)    │
└──────┬───────┘
       │ AST
       ▼
┌──────────────┐
│  语义分析     │  符号表、作用域、类型信息
│ (Semantic)   │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  规则引擎     │  800+ 规则并行执行
│  (Rules)     │
└──────┬───────┘
       │ Diagnostics
       ▼
┌──────────────┐
│  诊断输出     │  格式化报告、自动修复
│  (Reporter)  │
└──────────────┘

关键设计决策

  • 零拷贝 AST:解析器生成的 AST 直接在内存中供规则引擎使用,避免序列化/反序列化开销
  • 并行处理:文件级别的并行分析,充分利用多核 CPU
  • 增量分析:支持文件系统变更的增量检测,减少重复计算
  • 规则分类体系:按 correctness / suspicious / pedantic / restriction / nursery 五大类别组织

核心特性

1. 极致性能

基于 Rust 实现,比 ESLint 快 50-100 倍,比 Biome 快约 2 倍。实际迁移案例中,大型项目 lint 时间从分钟级降至秒级。

2. ESLint 生态兼容

  • 支持 500+ 条 ESLint 核心规则
  • 兼容 ESLint 插件系统(JS Plugins)
  • 支持 .eslintrc 配置的部分迁移
  • 提供 oxlint-eslint-plugin 桥接工具

3. 内置 TypeScript 支持

无需额外安装 TypeScript 类型检查器即可对 .ts / .tsx 文件进行 Lint,解析器原生理解 TypeScript 语法。

4. 类型感知 Lint(Type-Aware Linting)

基于 tsgo(Go 实现的 TypeScript 类型系统)提供真正的类型感知能力,无需运行 tsc

{
  "rules": {
    "no-unsafe-assignment": "error",
    "no-unsafe-member-access": "error",
    "no-unsafe-call": "error"
  }
}

5. 规则分类与分级

五大规则类别,支持灵活启用:

类别含义默认状态
correctness代码正确性问题warn
suspicious可疑代码模式warn
pedantic严格代码风格off
restriction限制性规则off
nursery实验性规则off

6. 自动修复(Auto-fix)

大量规则支持 --fix 自动修复,可在不改变语义的前提下自动修正代码问题:

npx oxlint --fix src/

7. ESLint JS 插件支持

Oxlint 从 v1.x 开始支持加载 ESLint 的 JavaScript 插件,允许复用社区生态中的自定义规则。

8. VS Code 集成

官方提供 oxc-vscode 扩展,支持实时诊断和快速修复。

9. 零配置开箱即用

默认启用 correctnesssuspicious 类别,无需任何配置即可在项目中使用:

# 零配置直接运行
npx oxlint

生态图

┌─────────────────────────────────────────────────────────┐
│                    Oxc 完整生态                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌─────────────┐   ┌─────────────┐   ┌──────────────┐ │
│  │   Oxlint    │   │    Oxfmt    │   │  oxc-parser  │ │
│  │  (Linter)   │   │ (Formatter) │   │  (解析器)    │ │
│  │  v1.71.0    │   │  v0.56.0    │   │              │ │
│  └─────────────┘   └─────────────┘   └──────────────┘ │
│                                                         │
│  ┌─────────────┐   ┌─────────────┐   ┌──────────────┐ │
│  │   oxc-      │   │   oxc-      │   │   oxc-       │ │
│  │  transform  │   │  minifier   │   │  bundler     │ │
│  │  (转译器)   │   │  (压缩器)   │   │ (打包器-规划)│ │
│  └─────────────┘   └─────────────┘   └──────────────┘ │
│                                                         │
│  ┌─────────────────────────────────────────────────┐   │
│  │              集成生态                            │   │
│  │  VS Code 扩展 · GitHub Actions · CI/CD 集成     │   │
│  │  Rollup / Vite 插件 · ESLint 桥接插件           │   │
│  └─────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────┘

与 Oxfmt 的协作

Oxfmt 是 Oxc 生态的代码格式化工具(对标 Prettier),与 Oxlint 配合可完全替代 ESLint + Prettier 组合:

// package.json scripts
{
  "scripts": {
    "lint": "oxlint src/",
    "format": "oxfmt src/",
    "check": "oxlint src/ && oxfmt --check src/"
  }
}

适用场景

1. 大型 Monorepo 项目

Oxlint 的并行处理能力使其在大型 monorepo 项目中优势明显。文件数量从数百增长到数万时,性能优势更加显著。

# Monorepo 根目录检查
npx oxlint packages/*/src/ apps/*/src/

2. CI/CD 流水线加速

在持续集成场景中,lint 步骤通常是瓶颈之一。Oxlint 可将 CI 中的 lint 时间从数分钟降至数秒:

# GitHub Actions 示例
- name: Lint
  run: npx oxlint --deny-warnings src/

3. 需要类型感知检查的 TypeScript 项目

无需运行 tsc --noEmit 即可获得类型感知的 lint 结果,大幅缩短反馈周期。

4. ESLint 性能优化替代

当 ESLint 在大型项目中变得缓慢时,Oxlint 可作为高性能替代方案,保留核心规则覆盖。

5. Pre-commit Hook 集成

配合 lint-stagedhusky,在提交前快速完成代码质量检查:

// lint-staged 配置
{
  "*.{js,ts,tsx,jsx}": ["oxlint --fix"]
}

6. 新项目快速启用代码规范

零配置即可运行,无需像 ESLint 那样安装大量插件和配置规则。

7. 代码迁移与重构辅助

在大规模代码迁移时,利用 Oxlint 的速度快速扫描整个代码库,识别潜在问题。

开发与工程化

配置文件详解

完整的 oxlintrc.json 配置示例:

{
  "$schema": "./node_modules/oxlint/configuration_schema.json",
  "rules": {
    "no-debugger": "error",
    "no-console": ["warn", { "allow": ["warn", "error"] }],
    "eqeqeq": ["error", "always"],
    "no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }]
  },
  "categories": {
    "correctness": "warn",
    "suspicious": "warn",
    "pedantic": "off",
    "restriction": "off",
    "nursery": "off"
  },
  "env": {
    "browser": true,
    "node": true,
    "es2024": true
  },
  "globals": {
    "MY_GLOBAL": "readonly"
  },
  "ignorePatterns": [
    "dist/",
    "node_modules/",
    "*.min.js"
  ],
  "overrides": [
    {
      "files": ["**/*.test.ts", "**/*.spec.ts"],
      "rules": {
        "no-console": "off"
      }
    }
  ],
  "plugins": ["react", "typescript", "import"]
}

与构建工具集成

Vite 集成

npm install -D vite-plugin-oxlint
// vite.config.ts
import { defineConfig } from 'vite'
import oxlint from 'vite-plugin-oxlint'
 
export default defineConfig({
  plugins: [oxlint()],
})

Turborepo 集成

// turbo.json
{
  "tasks": {
    "lint": {
      "inputs": ["src/**/*.ts", "src/**/*.tsx", "oxlintrc.json"]
    }
  }
}

CLI 参数参考

oxlint [options] [files...]
 
# 常用参数
--config, -c <path>      指定配置文件路径
--fix                    自动修复可修复的问题
--deny <rule>            将规则提升为 error 级别
--warn <rule>            将规则设置为 warn 级别
--allow <rule>           关闭指定规则
--deny-warnings warning 视为错误(CI 场景)
--ignore-pattern <glob>  忽略匹配的文件
--threads <number>       指定并行线程数(默认 CPU 核心数)
--format <format>        输出格式:default, json, github
--type-aware             启用类型感知规则

性能与安全

性能基准

来自 oxc-project/bench-linter 的官方基准数据:

工具相对性能说明
Oxlint1x(基准)Rust 实现,并行处理
Biome~2x 慢于 OxlintRust 实现
ESLint50-100x 慢于 OxlintJavaScript 实现,单线程

实际迁移数据(来自社区报告):

项目ESLint 耗时Oxlint 耗时加速比
大型商业项目4 分 30 秒2.4 秒~113x
中型开源项目28 秒0.8 秒~35x

安全特性

  • 默认启用正确性规则no-debuggerno-unsafe-optional-chaining 等默认开启
  • 类型感知安全检查no-unsafe-assignmentno-unsafe-member-access
  • 无远程代码执行风险:与 ESLint 的插件系统不同,Oxlint 核心规则不执行用户代码(JS 插件沙箱化)
  • 依赖链安全:Rust 原生二进制,减少供应链攻击面

技术对比

Oxlint vs ESLint

维度OxlintESLint
实现语言RustJavaScript
性能极快(50-100x)较慢(单线程 JS)
规则数量800+(持续增长)3000+(含插件生态)
TypeScript 支持原生内置需要 @typescript-eslint
类型感知 Lint内置(基于 tsgo)需要配置 type-aware linting
插件生态支持 ESLint JS 插件(新)极其丰富
配置复杂度低(零配置可用)高(需手动配置)
格式化能力无(需配合 Oxfmt)无(需配合 Prettier)
社区成熟度快速增长中非常成熟
自动修复支持(部分规则)支持(部分规则)

Oxlint vs Biome

维度OxlintBiome
实现语言RustRust
相对性能基准(1x)约 2x 慢
定位专注 LintLint + Format 一体
TypeScript 类型感知支持(tsgo)有限支持
ESLint 兼容性中等
规则数量800+200+(lint 部分)
格式化需配合 Oxfmt内置

Oxlint vs Ruff(Python 领域类比)

Oxlint 在 JavaScript/TypeScript 生态中的角色,类似于 Ruff 在 Python 生态中的角色——都是 Rust 实现的高性能替代方案。

最佳实践

1. 渐进式迁移策略

从 ESLint 迁移到 Oxlint 时,建议采用渐进式策略:

# 第一阶段:并行运行,对比结果
npx oxlint --format json > oxlint-results.json
npx eslint --format json > eslint-results.json
 
# 第二阶段:逐步关闭已覆盖的 ESLint 规则
# 在 .eslintrc 中关闭 Oxlint 已覆盖的规则
 
# 第三阶段:完全切换

2. CI 中使用 --deny-warnings

# CI 环境中将 warning 也视为错误,确保代码质量
npx oxlint --deny-warnings src/

3. 配合 ESLint 桥接使用

当 Oxlint 尚未覆盖某些 ESLint 插件规则时,可保留 ESLint 作为补充:

// .eslintrc.json - 关闭 Oxlint 已覆盖的规则
{
  "rules": {
    // Oxlint 已覆盖,关闭 ESLint 版本
    "no-debugger": "off",
    "no-console": "off",
 
    // Oxlint 尚未覆盖,保留 ESLint
    "custom-plugin/rule": "error"
  }
}

4. Pre-commit 快速反馈

// .husky/pre-commit
{
  "hooks": {
    "pre-commit": "lint-staged"
  }
}
 
// lint-staged.config.js
module.exports = {
  '*.{js,ts,tsx,jsx}': ['oxlint --fix --no-warn'],
}

5. 规则分级管理

{
  "categories": {
    "correctness": "error",
    "suspicious": "warn",
    "pedantic": "off"
  },
  "overrides": [
    {
      "files": ["*.test.ts", "*.spec.ts"],
      "categories": {
        "suspicious": "off"
      }
    }
  ]
}

6. 与 Oxfmt 组合替代 ESLint + Prettier

{
  "scripts": {
    "lint": "oxlint src/",
    "lint:fix": "oxlint src/ --fix",
    "format": "oxfmt src/",
    "format:check": "oxfmt --check src/",
    "quality": "pnpm lint && pnpm format:check"
  }
}

技术局限与边界

已知局限

  1. 规则覆盖尚未完整:虽已有 800+ 规则,但 ESLint 生态有 3000+ 规则(含插件),部分冷门插件规则尚未覆盖
  2. JS 插件支持尚在早期:ESLint JS 插件支持是新特性,部分复杂插件可能存在兼容问题
  3. 不支持自定义规则(Rust):编写自定义规则需要使用 Rust,而非 JavaScript
  4. 格式化能力需外部组件:Oxlint 本身不包含格式化功能,需配合 Oxfmt
  5. 配置格式不同于 ESLintoxlintrc.json.eslintrc 格式不完全兼容,需要迁移
  6. 生态成熟度:相比 ESLint 十余年的积累,社区教程、第三方集成仍在追赶

不适合的场景

  • 强依赖特定 ESLint 插件且无替代方案的项目
  • 需要自定义 JavaScript 规则且团队无 Rust 能力的项目
  • 对格式化有高度定制需求且 Oxfmt 尚未支持的场景
  • 需要与遗留构建系统深度集成的场景

学习资源

官方资源

官方公告

技术文章

社区与社交

2026 年现状

版本状态

截至 2026 年 7 月,Oxlint 的最新版本为 v1.71.0,保持了高频迭代节奏(约每周发布一个版本)。Oxc 生态的格式化组件 Oxfmt 已发展到 v0.56.0,从 Alpha 进入 Beta 阶段。

生态成熟度

  • 规则覆盖:800+ 规则,覆盖 ESLint 核心规则的大部分
  • 类型感知:基于 tsgo 实现真正的类型感知 Lint,无需依赖 tsc
  • 插件兼容:ESLint JS 插件支持已可用,持续扩展兼容范围
  • 企业采用:越来越多的大型项目在 CI 中采用 Oxlint 替代 ESLint

2026 路线图方向

根据 Q1 2026 路线图Q2 Milestone

  • 持续增加规则覆盖,向 ESLint 全规则兼容迈进
  • 完善 ESLint JS 插件兼容性
  • Oxfmt 从 Beta 走向稳定版
  • 探索 Bundler 组件的实现

趋势判断

Oxlint 已从"实验性替代方案"成长为"生产级首选工具"。在以下趋势下,其采用率预计将持续增长:

  1. 性能需求提升:项目规模持续扩大,ESLint 的性能瓶颈更加明显
  2. Oxc 生态成熟:Formatter、Bundler 等组件补齐后,形成完整的 Rust 工具链
  3. VoidZero 的商业支持:Vite 团队背后的公司提供持续投入
  4. TypeScript 深度集成:类型感知能力成为差异化竞争优势

相关资源: