✨ tsgolint ✨

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.

Why Teams Upgrade to Type-Aware Linting

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.

Installation & Usage

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

What these flags do

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

Configuration

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.

Note

Non-type-aware TypeScript rules can be found in Oxlint's TypeScript rules under the TypeScript source.

How it fits into Oxlint

Oxlint separates linting into two layers:

Layer	Purpose	Speed
Oxlint	Syntax & structural analysis	Instant
tsgolint	Type-aware semantic rules	Requires type analysis

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.

Why tsgolint exists

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:

Repository	ESLint + typescript-eslint	tsgolint	Speedup
microsoft/vscode	167.8s	4.89s	34x
microsoft/typescript	47.4s	2.10s	23x
typeorm/typeorm	27.3s	0.93s	29x
vuejs/core	20.7s	0.95s	22x

See benchmarks for detailed performance comparisons.

Status

tsgolint is stable and powers Oxlint's type-aware linting mode. See the Type-Aware Linting Stable announcement for details about the stable release.

Versioning

tsgolint is built directly on TypeScript 7, so its versions track the TypeScript release they support. For example, in v7.0.2001:

• 7.0.2 is the TypeScript version
• 001 is the tsgolint patch version

A fix released against the same TypeScript version increments the patch suffix, so the next release would be v7.0.2002. When the supported TypeScript version changes, the TypeScript portion changes and the patch suffix resets.

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

Note

We are not currently accepting PRs for new rules beyond what typescript-eslint supports, so that we can focus our limited engineering capacity on the items listed above.

For detailed technical documentation, see ARCHITECTURE.md.

Contributing

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 Rules

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

Links

• 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

Sponsored By