# Announcing Oxlint Type-Aware Linting Alpha

DEC 7, 2025

Michael Dong and Cameron Clark

3 MIN READ

> For more technical details, implementations, and considerations for Oxlint's type-aware linting, see the [blog post on the Oxc website](https://oxc.rs/blog/2025-12-08-type-aware-alpha.html).

**TL;DR:** Oxlint's type-aware linting has reached alpha status. Type-aware rules can now be manually configured, disabled with comments, and fixed automatically. This milestone also includes more rule coverage, TypeScript diagnostics reporting, and type-checking while linting.

* * *

Less than 6 months after the [**technical preview release**](/content/posts/announcing-oxlint-type-aware-linting/index.html), Oxlint's type-aware linting has reached alpha status. The goal for the technical preview was to build a proof of concept for type-aware linting in Oxlint. **VoidZero's goal for the alpha release is to better integrate Oxlint with `tsgolint`, which powers our type-aware lint rules.**

## What is `tsgolint`?

Type-aware rules like `no-floating-promises` can slow down linting because TypeScript may need to check every file to infer types. VoidZero accelerates this process using `tsgolint` to perform the underlying type checks and type-aware linting for Oxlint.

**`tsgolint` is a high-performant linter backend on top of `typescript-go`, the Go port of TypeScript.** Originally a proof-of-concept by [auvred](https://github.com/auvred) (typescript-eslint team), it's now maintained by VoidZero. Since `typescript-go` doesn't export internal packages, `tsgolint` provides a shim, an adapter layer on top of `typescript-go` that makes these internal APIs accessible. All type-aware rules are written directly against these shimmed internal APIs, keeping Oxlint fast while leveraging TypeScript's type system. `tsgolint` is not meant to run standalone. It is designed to be used as a backend for linters like Oxlint, providing type-aware linting capabilities.

Preliminary results show that **Oxlint + `tsgolint`** is significantly faster than **ESLint + `typescript-eslint`** ( [source](https://github.com/oxc-project/bench-linter)), given the same ruleset:

- **8x** faster in `vuejs/core`
- **12x** faster in `outline/outline`

However, a major consideration for this approach is maintenance and staying up-to-date with `typescript-go`. We regularly update `tsgolint` to depend on the latest `typescript-go` release and address any changes. While working on `tsgolint`, our team also submits pull requests to improve `typescript-go` and the overall ecosystem.

Oxlint is the developer's "frontend" interface that calls `tsgolint` as "linter backend" for type-aware linting.

## Better `tsgolint` integration with Oxlint

The goal for the alpha status was to reduce the distinction between type-aware rules and non-type-aware rules when using Oxlint.

1. **Rule configurations.** Type-aware rules can be separately configured in `.oxlintrc.json`

```json
// .oxlintrc.json
{
  "rules": {
    "typescript/no-floating-promises": [
      "error",
      {
        "ignoreVoid": true,
        "allowForKnownSafePromises": [
          { "from": "file", "name": "SafePromise" },
          { "from": "lib", "name": "PromiseLike" }
        ]
      }
    ]
  }
}
```

2. **In-line disable comment support**. Type-aware rules can be disabled per file or line.

```js
/* oxlint-disable typescript/no-floating-promises */

// oxlint-disable-next-line typescript/no-floating-promises
;[1, 2, 3].map(async (x) => x + 1)
```

3. **Automatic fixes**. Type-aware rules now support automatic fixes using the `--fix` flag.

All 3 updates bring type-aware rule features closer to parity with non-type-aware rules.

## Additional improvements

In addition to more stability, Oxlint's type-aware linting alpha comes with:

- **Type-checking while linting**. Oxlint can emit type checking errors from TypeScript while linting. Meaning, in some cases, it's possible to skip doing a separate type-check command altogether (e.g., `tsc --noEmit`) and reduce total time spent linting and type-checking in CI. You can enable it via the `--type-check` flag.
- **More supported rules**. Oxlint added support for `no-deprecated`, `prefer-includes`, `strict-boolean-expressions` rules. It now covers 43 / 59 `typescript-eslint` rules. [All supported rules](https://oxc.rs/docs/guide/usage/linter/type-aware.html#supported-rules).
- **TypeScript diagnostics**. Oxlint reports any TypeScript compiler issues or configuration issues in `tsconfig.json` files.

## Next steps

VoidZero is actively working on the following improvements for the beta release:

- **Increase type-aware rules support.** Expand coverage to the remaining `typescript-eslint` rules.
- **Memory usage optimization.** In very large monorepos, `tsgolint` may encounter out-of-memory issues. Our team is working improving memory usage for the next milestone. If you are having memory issues please report it in the [tsgolint repository](https://github.com/oxc-project/tsgolint/issues).