# Faster Type-Aware Lint Rules: Biome vs. Oxlint

2025-07-19

ESLint and TypeScript-ESLint are indispensable. Their type-aware rules—`no-floating-promises`, the entire `no-unsafe-*` family, and dozens more—have become the backbone of production-grade TypeScript codebases. They catch real bugs before a single test is run. The cost, unfortunately, is speed: a cold run of `typescript-eslint` on our monorepo at [TripToJapan.com](https://www.triptojapan.com) is 7 minutes. That is the tax we pay for safety.

![Oxlint and Biome duking it out](https://ss.solberg.is/bPBBRYBz+)

**A new breed of Rust-based linters is now orders-of-magnitude faster—but they ship without any type information.**  
Both **Biome 2** and **Oxlint** (from the Vite/OXC family) can lint our entire codebase in < 1.5 s. The catch: their current rule sets are purely syntactic. You lose the guarantees that catch un-awaited promises, unsafe assignments, or calls to `any`-typed values—exactly the rules that justify `typescript-eslint` in the first place.

**Biome is solving the problem with a ground-up type synthesizer.**  
Their new engine, **Biotype**, re-implements TypeScript’s checker in Rust. The first rule to ship, [`noFloatingPromises`](https://biomejs.dev/linter/rules/no-floating-promises/), proves the concept works. But each additional rule demands a comparable research effort, and every edge case in the TypeScript spec risks a silent deviation from official behaviour. As [Evan You put it](https://x.com/youyuxi/status/1946510002518466926):

> “Biome’s type-aware linting is based on a custom type synthesizer — it cannot guarantee full coverage or behavior alignment with official TS.”

**Oxlint is taking a different bet: wait for the official TypeScript compiler to get fast.**  
Their experimental project **tsgolint** is a thin wrapper around **tsgo**, the Go port of the TypeScript compiler that the TS team is actively working on. The idea is simple: let the canonical checker do the heavy lifting, then run the 40 high-value `typescript-eslint` rules on top. Evan You summarised the rationale:

> “We want to provide type-aware linting by actually getting the type info from TS for full alignment.”

Because `tsgo` is progressing rapidly—cold type-checking is already 5–7× faster in internal builds—Oxlint’s gamble is that the gap between “fast” and “accurate” will soon close entirely.

**Meanwhile, the community is exploring a third path: piggy-back on the editor’s already-running language server.**  
Projects like [tsslint](https://github.com/johnsoncodehk/tsslint) (Volar) and [tsl](https://github.com/ArnaudBarre/tsl) hook into existing `tsserver` or `tsc` instances. This eliminates the duplicate memory footprint of running type-compile `tsc` and then linting with typescript-eslint. This can result in a [significant boost](https://x.com/_ArnaudBarre/status/1947214368271175853) for both CI and IDE linting.

**My conclusion: Oxlint is making the right long-term bet.**  
By aligning with `tsgo`, they inherit every future optimisation the TypeScript team ships, while keeping the rule surface identical to `typescript-eslint`. Once `tsgolint` graduates from experimental to stable, Oxlint will wrap it and ship the full 40-rule suite in one release—no gradual catch-up, no behavioural drift. That is the moment we will drop the hybrid setup and run a single, blazing-fast linter that already understands our codebase.

UPDATE: Oxlint is now aiming for [July 28 launch of typed rules](https://x.com/boshen_c/status/1947594019326103662)

---

### Appendix: Timeline of Milestones  

-  **April 2024** – Biome ships `noFloatingPromises`, first rule via Biotype  
-  **May 2024** – typescript-eslint adds Project Service integration  
-  **June 2025** – Oxlint 1.0 released, 30× faster than ESLint on syntax rules  
-  **Q3 2025 (expected)** – Biome expands to ~10 type-aware rules  
-  **Q3–Q4 2025 (expected)** – **tsgolint** lands in Oxlint as experimental  
-  **Late 2025** – `tsgo` CLI reaches beta with 10× faster type-checking  
-  **Early 2026 (speculative)** – Oxlint + tsgolint becomes the recommended path for type-aware linting

### Links  

-  [Oxlint Linter Documentation](https://oxc-project.github.io/docs/guide/linter.html)  
-  [`eslint-plugin-oxlint`](https://github.com/oxc-project/eslint-plugin-oxlint)  
-  [`tsgolint`](https://github.com/oxc-project/tsgolint) (proof-of-concept)  
-  [Biome official website](https://biomejs.dev/)  
-  [`noFloatingPromises`](https://biomejs.dev/linter/rules/no-floating-promises/)  
-  [Making Prettier fast](http://solberg.is/prettier-is-fast)  
-  [typescript-eslint Project Service blog post](https://typescript-eslint.io/blog/project-service-and-faster-linting/)  
-  [Evan You on Oxlint + tsgolint strategy](https://x.com/youyuxi/status/1944716435886067866)