# Oxc — The JavaScript Oxidation Compiler Written in Rust

> Oxc is a Rust-based collection of JavaScript tools — parser, linter, resolver, transformer, and minifier — designed to be the fastest in each category. It underpins next-generation web tools like Rolldown and provides drop-in replacements for ESLint, Babel, and terser.

## Install

Save in your project root:

# Oxc — JavaScript Oxidation Compiler in Rust

## Quick Use
```bash
# Linter (ESLint-compatible)
npm install -g oxlint
oxlint src

# Transformer (Babel-compatible) via Rolldown or direct API
```

## Introduction
Oxc is the JavaScript Oxidation Compiler — a Rust toolkit building the fastest JS/TS parser, linter, transformer, resolver, and minifier. Backed by Void(0) and used as the engine behind Rolldown (Vite's next bundler), Oxc is quietly becoming the foundation of the modern JS toolchain.

With over 21,000 GitHub stars, Oxc components are already replacing Babel, ESLint, and terser in production bundlers. The linter (oxlint) is 50–100x faster than ESLint on large codebases.

## What Oxc Does
Oxc provides five core modules: (1) **Parser** — the fastest JS/TS/JSX parser; (2) **Resolver** — Node.js module resolution in Rust; (3) **Linter (oxlint)** — ESLint-compatible rules at warp speed; (4) **Transformer** — Babel plugin equivalents; (5) **Minifier** — terser-compatible minification.

## Architecture Overview
```
Source code (.js/.ts/.jsx/.tsx)
        |
  [Oxc Parser]  AST in ~µs-ms
        |
  +-------+-------+-------+-------+
  |       |       |       |       |
[oxlint] [Resolver] [Transformer] [Minifier]
  rules   path      codegen       compressor
          resolution
        |
  Consumers:
  - Rolldown (bundler)
  - Rspack   (build-step integration)
  - Farm, tsdown, and others
```

## Self-Hosting & Configuration
```jsonc
// .oxlintrc.json
{
  "$schema": "./node_modules/oxlint/configuration_schema.json",
  "plugins": ["typescript", "react", "import"],
  "rules": {
    "no-unused-vars": "warn",
    "no-console": "error",
    "typescript/no-explicit-any": "warn"
  },
  "ignorePatterns": ["dist", "build", "node_modules"]
}
```

```bash
# Lint with warnings as errors (CI mode)
oxlint --deny-warnings src
# Run alongside ESLint during migration
oxlint src  # catches the fast rules in milliseconds
# Keep ESLint for rules oxlint does not yet implement
```

## Key Features
- **Fastest parser** — benchmarked 2–3x faster than SWC, 20x+ faster than Babel
- **oxlint** — 50–100x faster than ESLint; 500+ rules and growing
- **Node.js resolver** — spec-compliant, used by Rolldown and Rspack
- **Transformer** — TypeScript and JSX lowering; Babel plugin parity expanding
- **Minifier** — terser-compatible bytes, dramatically faster builds
- **Deno/Bun ready** — works in Rust and via WASM bindings
- **Zero config** — sensible defaults, easy to adopt
- **Ecosystem** — powers Rolldown, tsdown, Farm, and upcoming Vite versions

## Comparison with Similar Tools
| Feature | Oxc | SWC | Babel | ESLint | Biome |
|---|---|---|---|---|---|
| Language | Rust | Rust | JS | JS | Rust |
| Parser speed | Fastest | Very fast | Slow | N/A | Very fast |
| Linter | oxlint | No | No | Yes | Yes |
| Transformer | Yes | Yes | Yes | No | No |
| Minifier | Yes | Yes | No | No | No |
| Ecosystem | Growing | Mature | Largest | Largest | Growing |
| Best For | Modern toolchains | Next.js/Turbopack | Legacy configs | Any lint rules | All-in-one |

## FAQ
**Q: Oxc vs SWC — they do similar things?**
A: Both are Rust-based JS toolchains. SWC powers Next.js and Turbopack. Oxc aims for higher performance and a broader module set (linter, resolver, minifier). In many benches Oxc is measurably faster.

**Q: Can I replace ESLint with oxlint today?**
A: For most common rules, yes — gradually. oxlint doesn't yet cover 100% of ESLint's plugin ecosystem. Run both in parallel during migration, keeping ESLint for niche rules.

**Q: Oxc vs Biome?**
A: Biome is an all-in-one (format + lint + more) aiming for developer ergonomics. Oxc is component-based, designed to be embedded in bundlers and other tools. Pick Biome for projects; Oxc for building tools.

**Q: What will Vite use?**
A: Vite's upcoming bundler is Rolldown, which uses Oxc internally. So indirectly, Oxc will power Vite builds.

## Sources
- GitHub: https://github.com/oxc-project/oxc
- Website: https://oxc.rs
- Org: Void(0)
- License: MIT

---
Source: https://tokrepo.com/en/workflows/dc46ca98-37be-11f1-9bc6-00163e2b0d79
Author: AI Open Source