tsgolint is a high-performance TypeScript linter containing only type-aware rules, powered by typescript-go and designed for integration with Oxlint.

Key highlights:

• Performance: 20-40x faster than ESLint + typescript-eslint
• Type-aware: Comprehensive TypeScript type checking integration
• Parallel: Utilizes all available CPU cores
• Compatible: Implements typescript-eslint rules with consistent behavior

This project originated in typescript-eslint/tsgolint. Fork permission is granted by @auvred.

[!IMPORTANT] tsgolint is a prototype in the early stages of development. This is a community effort. Feel free to ask to be assigned to any of the good first issues.

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

Configuration

Configure type-aware rules in .oxlintrc.json:

{
  "$schema": "./node_modules/oxlint/configuration_schema.json",
  "rules": {
    "typescript/no-floating-promises": "error",
    "typescript/no-misused-promises": "error"
  }
}

Over 30 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.

Performance

tsgolint is 20-40 times faster than ESLint + typescript-eslint.

Real-World Performance Examples

• napi-rs (144 files): 1.0s
• preact (245 files): 2.7s
• rolldown (314 files): 1.5s
• bluesky (1152 files): 7.0s

Speed Sources

• Native Speed: Go implementation with direct TypeScript compiler integration
• Zero Conversion: Direct TypeScript AST usage without ESTree conversion overhead
• Parallel Processing: Multi-core execution utilizing all available CPU cores
• Efficient Memory: Streaming diagnostics and optimized resource usage

See benchmarks for detailed performance comparisons.

Current Status

In Development 🚧

• Additional typescript-eslint rules
• Disable Comments
• Rule Configuration
• IDE usage

Architecture

tsgolint follows a clean separation between frontend and backend:

• Oxlint CLI handles file discovery, configuration, and output formatting
• tsgolint backend provides type-aware rule execution and diagnostics
• TypeScript integration via typescript-go for native performance

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 (43/59)

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