High-performance type-aware linting for Oxlint.

tsgolint executes lint rules that require TypeScript semantic analysis, using typescript-go for full compatibility with the TypeScript type system, and targets TypeScript 7 (codenamed Project Corsa).

It is designed to integrate seamlessly with Oxlint's fast syntax linting, enabling projects to run deeper semantic checks without sacrificing performance.

Key highlights:

• Performance: 20-40x faster than ESLint + typescript-eslint on large repositories
• Coverage: 59/61 targeted typescript-eslint type-aware rules implemented
• Parallel: Multi-core rule execution for scalable analysis
• High impact: catches production-grade bugs that syntax-only linting misses (for example no-floating-promises)

This project originated in typescript-eslint/tsgolint, with fork permission granted by @auvred.

If you ship TypeScript, running oxlint --type-aware in CI is a high-leverage upgrade that catches bug classes syntax linting cannot.

For example, typescript/no-floating-promises catches silently dropped async failures:

async function saveUser(user) {
  const res = await fetch('/api/users', {
    method: 'POST',
    body: JSON.stringify(user),
  });
  if (!res.ok) throw new Error('save failed');
}

function onSubmit(user) {
  saveUser(user); // no-floating-promises: Promise is created but never handled
  showToast('Saved!'); // UI claims success even if the request rejects
}

Without this rule, rejected promises can be missed and reach production as flaky, hard-to-debug failures.

tsgolint is integrated into Oxlint as the type-aware backend. Install and use via Oxlint:

# Install oxlint with type-aware support
pnpm add -D oxlint-tsgolint@latest

# Quick start
pnpm dlx oxlint --type-aware

# Or run on your project
oxlint --type-aware

# Optionally also run typechecking at the same time
oxlint --type-aware --type-check

• --type-aware: enables typescript/* rules that require TypeScript semantic analysis via tsgolint
• --type-check: includes type diagnostics from typescript-go in type-aware runs

Configure type-aware rules in .oxlintrc.json:

{
  "$schema": "./node_modules/oxlint/configuration_schema.json",
  // alternatively, configure via options field
  "options": {
    "typeAware": true,
    "typeCheck": true,
  },
  "rules": {
    "typescript/no-floating-promises": "error",
    "typescript/no-misused-promises": "error",
  },
}

Over 50 TypeScript-specific type-aware rules are available. For detailed setup and configuration, see the Oxlint Type-Aware Linting guide.

Oxlint separates linting into two layers:

This architecture keeps the common case extremely fast while enabling powerful type-aware checks when needed. Oxlint handles file discovery, configuration, and output formatting, while tsgolint executes type-aware rules and emits semantic diagnostics.

Traditional type-aware linting in the JavaScript ecosystem typically works by embedding TypeScript's type-analysis engine inside a JavaScript linter.

This approach introduces several bottlenecks:

• slow startup due to compiler initialization
• AST conversion between toolchains
• limited parallelism
• high memory overhead on large repositories

tsgolint takes a different approach: it runs directly on typescript-go, avoiding these bottlenecks and allowing semantic analysis to run efficiently alongside Oxlint.

Recent benchmark results (eslint + typescript-eslint vs tsgolint) show consistent large speedups:

See benchmarks for detailed performance comparisons.

tsgolint is under active development.

The core architecture is stable and already powers Oxlint's type-aware linting mode. Current development focuses on expanding rule coverage and ecosystem integration:

• additional typescript-eslint rule support
• editor integration improvements
• configuration and rule customization
• performance improvements for large monorepos

Because tsgolint relies on typescript-go, its long-term stability evolves alongside TypeScript itself.

For detailed technical documentation, see ARCHITECTURE.md.

We welcome contributions! See CONTRIBUTING.md for:

• Development setup and building instructions
• Testing procedures and guidelines
• How to implement new rules
• Code style and contribution workflow

Implemented 59/61.

• naming-convention
• prefer-destructuring
• await-thenable
• consistent-return
• consistent-type-exports
• dot-notation
• no-array-delete
• no-base-to-string
• no-confusing-void-expression
• no-deprecated
• no-duplicate-type-constituents
• no-floating-promises
• no-for-in-array
• no-implied-eval
• no-meaningless-void-operator
• no-misused-promises
• no-misused-spread
• no-mixed-enums
• no-redundant-type-constituents
• no-unnecessary-boolean-literal-compare
• no-unnecessary-condition
• no-unnecessary-qualifier
• no-unnecessary-template-expression
• no-unnecessary-type-arguments
• no-unnecessary-type-assertion
• no-unnecessary-type-conversion
• no-unnecessary-type-parameters
• no-unsafe-argument
• no-unsafe-assignment
• no-unsafe-call
• no-unsafe-enum-comparison
• no-unsafe-member-access
• no-unsafe-return
• no-unsafe-type-assertion
• no-unsafe-unary-minus
• no-useless-default-assignment
• non-nullable-type-assertion-style
• only-throw-error
• prefer-find
• prefer-includes
• prefer-nullish-coalescing
• prefer-optional-chain
• prefer-promise-reject-errors
• prefer-readonly-parameter-types
• prefer-readonly
• prefer-reduce-type-parameter
• prefer-regexp-exec
• prefer-return-this-type
• prefer-string-starts-ends-with
• promise-function-async
• related-getter-setter-pairs
• require-array-sort-compare
• require-await
• restrict-plus-operands
• restrict-template-expressions
• return-await
• strict-boolean-expressions
• strict-void-return
• switch-exhaustiveness-check
• unbound-method
• use-unknown-in-catch-callback-variable

• ARCHITECTURE.md - Detailed technical documentation
• CONTRIBUTING.md - Development and contribution guidelines
• Benchmarks - Performance comparison data
• typescript-go - Underlying type-analysis backend
• Oxlint - Frontend linter integration