tsgolint v7: Go Speed for Type-Aware TypeScript Linting

Bridging Go, Rust, and TypeScript for Faster Linting

The release of tsgolint v7 marks a significant advancement in the realm of TypeScript linting by leveraging Go's performance through the typescript-go project and integrating it with Oxlint's Rust-based engine. The key innovation lies in its ability to perform type-aware linting without reimplementing a type checker, instead building upon the official TypeScript compiler. This approach promises substantial speedups, with benchmarks showing 12-18x faster execution compared to ESLint with typescript-eslint. The alignment with TypeScript's compiler versions ensures feature parity and future-proofs the linting rules, a strategic advantage over custom-built type checkers that often struggle to keep pace. The direct integration with Oxlint, which handles syntactic rules and infrastructure, creates a powerful, hybrid linting solution.

However, potential concerns revolve around the increased complexity of the toolchain. Developers now depend on a Go binary for type-aware checks, adding a new dependency layer. While the compatibility is stated to be with TypeScript v7.0.2, projects relying on older or deprecated TypeScript features might face migration hurdles. The statement that the original typescript-eslint fork is 'not under active development' also hints at a potential fragmentation of effort within the ecosystem. For users of Biome, the comparison highlights a trade-off: Biome's self-synthesized types offer a lighter dependency but at the cost of completeness compared to using the actual compiler. The adoption of tsgolint is therefore a conscious decision to prioritize correctness and performance over a completely self-contained solution, which might not appeal to all teams, especially those with strict dependency management policies or those on the bleeding edge of TypeScript features that might not yet be fully supported by typescript-go.

This development is highly beneficial for large-scale TypeScript projects that are sensitive to build times and code quality. Teams currently struggling with slow ESLint runs, particularly those with extensive type-aware rules, will find tsgolint v7 a compelling alternative. Developers looking to adopt a more performant and accurate linting solution will be eager to try this out, especially with the straightforward migration path offered for ESLint configurations. The technical implications are substantial, pushing the boundaries of static analysis by effectively bringing the power of the TypeScript compiler itself into the linting process. This not only speeds up development cycles but also enhances code reliability by catching more nuanced errors that purely syntactic analysis would miss. The long-term bet on aligning with the official compiler seems sound, as it ensures that the linting rules accurately reflect the behavior of the TypeScript compiler, reducing the likelihood of false positives or negatives. The focus on editor integration and monorepo performance in future work further solidifies its potential as a mainstream linting solution.

Key Points

• tsgolint v7, the type-aware linting engine for Oxlint, has reached a stable release.
• It leverages Go's performance via typescript-go, integrating with Oxlint's Rust core.
• Achieves 12-18x faster performance than ESLint with typescript-eslint on benchmark projects.
• Directly uses the TypeScript compiler for type-aware analysis, ensuring accuracy and feature parity.
• Covers 59 out of 61 typescript-eslint type-aware rules.
• Offers a migration path for ESLint users and supports pinning configuration in oxlint.config.ts or .oxlintrc.json.
• Requires TypeScript 7.0 or later, potentially impacting projects using legacy tsconfig options or older TypeScript features.

---

📖 Source: tsgolint Reaches Stable v7, Bringing Go-Powered Type-Aware Linting to Oxlint