Tag: linting

Slow linting, formatting, and parsing often bottleneck large JavaScript and TypeScript projects, costing valuable developer time and limiting how teams streamline CI/CD and editor feedback. The JavaScript Oxidation Compiler (Oxc) aims to break these limits by reimagining the entire JS toolchain in Rust—delivering a unified, high-performance suite for linting, formatting, parsing, resolving, transforming, and minifying code. This post cuts through the hype to show what Oxc actually delivers, how its tools work together, and the real-world tradeoffs for practitioners considering migration right now.

Key Takeaways:

• Oxc is an open-source, Rust-powered suite for linting, formatting, parsing, transforming, resolving, and minifying JavaScript and TypeScript.
• Benchmarks show Oxc tools are dramatically faster than legacy options—e.g., parsing 3x faster than SWC, linting up to 100x faster than ESLint, and formatting up to 35x faster than Prettier.
• Oxc powers next-generation tools such as Rolldown, the future bundler for Vite, and emphasizes compatibility and incremental adoption.
• Official CLI commands and installation methods are not published; Oxc is primarily distributed as Rust binaries. Practitioners should refer to the official repo for usage details.
• Alpha and beta status tools require careful validation, especially around plugin compatibility and advanced TypeScript features.

What Is the JavaScript Oxidation Compiler?

The JavaScript Oxidation Compiler (Oxc) is a collection of high-performance tools for JavaScript and TypeScript, entirely written in Rust and developed under the Oxc project (project homepage). Unlike narrowly-scoped Rust rewrites, Oxc’s ambition is to replace the entire JavaScript toolchain—linter, formatter, parser, transformer, resolver, and minifier—with a modular but tightly integrated suite.

• MIT-licensed and open source; free for commercial and personal use.
• Cross-platform; community reports confirm stable builds across Windows, macOS, and Linux (see example).
• Rapid development; Oxlint already supports 650+ rules, and the ecosystem is expanding quickly (Oxlint v1.0 announcement).

Oxc is already powering real-world projects, including Rolldown (the upcoming Vite bundler). Its goal: provide “blazing speed” and seamless compatibility so large teams can adopt modern workflows with minimal migration friction. Oxc is not just about incremental gains—it’s a bid to make slow toolchains obsolete in production-scale JS/TS stacks.

Oxc’s scope covers the following legacy replacements:

• ESLint (replaced by Oxlint: up to 100x faster linting)
• Prettier/Biome (replaced by Oxfmt: up to 35x faster formatting)
• SWC/Babel (replaced by oxc-parser and oxc-transform)
• enhanced-resolve (replaced by oxc-resolver: 28x faster)
• Terser/Uglify (replaced by oxc-minify, currently alpha)

Oxc’s compatibility-first design means you can often use your existing configs and workflows, minimizing the risk when evaluating or migrating.

Core Tools and Architecture

The Oxc ecosystem is modular, with each tool targeting a specific stage of the JS/TS workflow. These tools are written in Rust, and as of now, the official distribution is as Rust binaries, not npm packages. For all installation and usage, refer to the official documentation.

Linting: Oxlint

• ESLint-compatible linter, supporting JS plugins and config files.
• Delivers up to 100x faster linting compared to ESLint, especially noticeable in monorepos and CI pipelines.
• Supports type-aware linting powered by tsgo, enabling checks based on TypeScript types.
• 650+ rules and growing; stable and production-ready as of the latest release (release notes).

# Example: To use Oxlint, download the Rust binary from the official releases.
# Build from source (Rust toolchain required):
git clone https://github.com/oxc-project/oxc.git
cd oxc
cargo build --release

# Run the linter (see documentation for CLI options):
# ./target/release/oxlint [options]

Why it matters: Teams can use Oxlint as a drop-in linter for large codebases, with much faster feedback cycles. Its ESLint compatibility allows gradual migration—run Oxlint in CI or alongside existing tools while building confidence in results and plugin support.

Formatting: Oxfmt

• Prettier-compatible formatter (currently in Alpha).
• Benchmarks show 3x faster performance than Biome and 35x faster than Prettier on large codebases (see official benchmarks).
• Supports Tailwind class sorting and many Prettier configuration options.

# Example: Build Oxfmt from source (see official documentation for details)
git clone https://github.com/oxc-project/oxc.git
cd oxc
cargo build --release

# Run the formatter (refer to documentation for CLI usage):
# ./target/release/oxfmt [options]

Why it matters: Oxfmt enables format-on-save and pre-commit formatting at scales previously impractical due to speed. Fast formatting reduces merge conflicts and improves code consistency, especially in large, multi-developer codebases.

Parsing, Transforming, Resolving, Minifying

• oxc-parser: Parses both .js(x) and .ts(x), passes all TC39 Test262 stage4 tests, and is 3x faster than SWC.
• oxc-transform: Transpiles TypeScript & JSX to ES2015+, supports React Fast Refresh and emits DTS files.
• oxc-resolver: Node.js-compatible CJS and ESM resolution, 28x faster than enhanced-resolve.
• oxc-minify: Alpha-stage minifier offering dead code elimination, whitespace removal, and syntax shortening.

# Example: Build and run oxc-parser or oxc-minify
git clone https://github.com/oxc-project/oxc.git
cd oxc
cargo build --release

# Run parser, transformer, resolver, or minifier from ./target/release/
# Refer to official documentation for CLI syntax and options

Why it matters: These tools can be chained in build pipelines, replacing slow legacy steps with high-speed Rust-native equivalents. Oxc’s focus on compatibility and modularity allows phased adoption and easy rollback if issues are encountered.

Usage Patterns and Adoption Strategies

Oxc tools are being adopted by practitioners looking to speed up CI/CD, improve developer feedback, and modernize legacy workflows. Because Oxc is distributed as Rust binaries, adoption strategies typically include:

CI/CD Pipeline Acceleration

• Replacing slow lint and format steps with Oxc binaries can cut pipeline times from minutes to seconds in large projects.
• Parallelization: Oxc tools leverage Rust’s native multithreading, maximizing CI runner hardware.
• Type-aware linting in CI enables strong TS checks without the full tsc compile step.

# Example GitHub Actions step
- name: Lint and format with Oxc tools
  run: |
    ./target/release/oxlint . 
    ./target/release/oxfmt .
  # (Adjust paths and options based on project structure)

Why it matters: Faster CI cycles mean less wait for contributors, more frequent code quality checks, and lower compute costs. Teams can incrementally introduce Oxc tools in CI before fully switching over locally.

Editor and Tool Integration

• Oxc binaries can be wired into editors like VS Code using “external tool” integrations or format-on-save hooks.
• Instant feedback enables real-time linting and formatting even in large monorepos.
• Monorepo and multi-package workspaces are supported via configuration inheritance and flexible CLI options.

For details on optimizing file navigation and workflow in VS Code, see our internal guide on efficient file navigation in VS Code.

Bundler and Build System Integration

• Rolldown, Vite’s upcoming bundler, uses Oxc for parsing, transforming, and minifying, improving local dev environment speed.
• Teams can migrate by project, package, or file type, reducing migration risk and enabling gradual rollout.
• Invoke Oxc tools from scripts, Makefiles, or custom orchestrators—no need to rewrite the entire toolchain at once.

# Example Makefile fragment
lint:
	./target/release/oxlint src/
format:
	./target/release/oxfmt src/
build:
	# Integrate parser/transform/minify as needed

Why it matters: Oxc’s modularity and legacy config compatibility make it feasible for established codebases to migrate one step at a time, with clear fallback paths.

Performance Benchmarks and Comparisons

Oxc’s performance claims are backed by official project benchmarks. For example, parsing typescript.js on a Macbook Pro M3 Max yields:

Other reported speedups (from official sources):

• Linting: Oxlint is 50–100x faster than ESLint on large projects.
• Formatting: Oxfmt is up to 35x faster than Prettier and 3x faster than Biome.
• Module resolution: oxc-resolver is 28x faster than enhanced-resolve.

All speed claims and benchmarks are from official Oxc documentation. Always validate performance on your own hardware and representative codebase.

For related coverage on high-performance tooling and hardware-accelerated workflows, see our post on NVMe-to-GPU inference for LLMs.

Common Pitfalls and Pro Tips

• Installation and CLI: Oxc tools are not published as npm packages. Always refer to the official repo for installation and CLI usage. Do not attempt to install using npm install or similar methods unless specifically documented.
• Alpha/Beta Status: Oxlint and oxc-parser are production-ready, but Oxfmt and oxc-minify are still in alpha. Pin versions and maintain fallback paths when adopting these tools in production.
• Config and Plugin Compatibility: While Oxc aims for ESLint and Prettier compatibility, some custom or legacy plugins may require adjustment—especially those with binary or native dependencies.
• TypeScript Edge Cases: Oxc’s type inference may differ from tsc in advanced generic or ambient type scenarios. Run type checks separately until parity is confirmed.
• Cross-Platform Validation: Oxc is confirmed to work on Windows, but always test in your CI matrix for file system and path edge cases (see example).
• Incremental Adoption: Migrate one Oxc tool at a time—start with linting or parsing, compare output and performance, then expand to formatting and minification.

For more on orchestrating high-performance dev setups, see our deep dive into real-world dashboard builds.

Conclusion and Next Steps

Oxc is not just about shaving milliseconds—it’s about enabling new, high-velocity development patterns. If your team is blocked by slow CI, sluggish formatting, or inconsistent tooling, Oxc’s Rust-based approach is ready for serious evaluation. Start with Oxlint or oxc-parser for quick wins, then expand as the ecosystem matures.

Track new releases and integrations at the official Oxc GitHub repo and project homepage. For related workflow improvements, see our guide to file navigation in VS Code.

The wave of Rust-powered, cross-platform JS tooling is here. Validate Oxc on your own stack—measure, compare, and decide where high-performance truly moves the needle for your team.