typescript-eslint

tsgolint: Lint TypeScript with Microsoft's typescript-go

tsgolint is an experimental Go linter for JavaScript and TypeScript, powered by Microsoft's typescript-go. It prototypes type-aware typescript-eslint rules and a parallel linting engine, but is inactive and not intended for production use.

View on GitHub Compare
Stars
520
Forks
6
Stars, last 30 days
+3
Last commit
1.3 years ago
Contributors
4

Our take

Inactiveno commits in over a year

Health score

20/100

How it is scored
Activity
19
Community
19
Issues
21
Pull requests
20

+3 stars in the last 30 days

tsgolint is a useful architecture and performance experiment, but its inactive, early-stage status makes it unsuitable as a production linter.

Good fit if

  • You want to explore a Go-based, typescript-go-powered approach to type-aware linting.
  • You are evaluating linter internals or prototyped typescript-eslint rules, and can build the project from source.

Look elsewhere if

  • You need an actively maintained, production-ready linter or dependable release cadence.
  • You need non-type-aware rules, a configuration file, a plugin system, an editor extension, or a feature-rich CLI.
  • Your workflow depends on JavaScript-based plugins, which are not supported by the main branch.
All health signals
Last commit2025-07-13 (1.3 years ago)
Commits, last 90 days0
Releases, last 12 months0
Contributors4 (top contributor: 96% of commits)
Issues closed, last 90 days0
Pull requests merged, last 90 days0
Project age19 months

Checked on 2026-10-15 with the GitHub API.

Project history

Daily GitHub snapshots since Oct 7, 2026. History covers stars and forks; health signals are not tracked historically.

Selected snapshot

Stars

523

Forks

6

Change since Nov 12, 2026: 0 stars·0 forks

Overview

tsgolint is an experimental proof of concept for linting JavaScript and TypeScript in Go, powered by Microsoft's typescript-go. It explores whether using TypeScript's Go implementation for parsing and type-checking can make type-aware linting faster, while applying rules directly to the TypeScript AST.

The project is aimed at people exploring linter architecture and performance, rather than teams looking for a production-ready replacement for ESLint. Its maintainers describe it as an experiment, not an indication that typescript-eslint is moving away from ESLint.

Key Features

  • Implements 40 type-aware rules from typescript-eslint.
  • Provides a basic command-line linter.
  • Prototypes a linter engine and a rule-testing tool.
  • Includes a source-code fixer.
  • Uses typescript-go for parsing and type-checking, and operates directly on the TypeScript AST.
  • Runs parsing, type-checking, and linting in parallel across available CPU cores.

Use Cases

  • Linter developers can study how a Go implementation might handle type-aware linting.
  • TypeScript tooling researchers can explore direct use of the TypeScript AST instead of converting it to ESTree.
  • Developers can inspect prototype implementations of typescript-eslint rules and their test infrastructure.
  • Teams investigating faster typed linting can use the experiment to inform evaluation of the typescript-eslint discussion about typescript-go.

What you need

Detected in the repository

  • Go 1.24.1 or newer (from go.mod)

License in plain words

MITpermissive

  • Commercial use: yes
  • Modify and redistribute: yes
  • You must keep: the copyright and license notice
  • Share your changes: no

A summary, not legal advice: the LICENSE file is what applies.

Getting Started

The repository requires Go 1.24.1 and a typescript-go submodule. From the repository root:

git submodule update --init
cd typescript-go && git am --3way --no-gpg-sign ../patches/*.patch && cd ..
go build -o tsgolint ./cmd/tsgolint

See the README for build details and the repository's benchmarks for its performance tests.

Considerations

The project is explicitly a prototype and is not actively developed. There have been no commits in over a year and no releases in the past year. Most of the code comes from one person, and the available activity data shows no recent issue closures or merged pull requests. Treat the code and its performance claims as experimental, not as a maintained production option.

The main branch does not provide non-type-aware rules, configuration files, a plugin system, editor support, or a rich CLI. JavaScript plugins are unsupported in the main branch; the README describes an experimental compatibility branch whose performance was significantly worse than ESLint running in Node.js. Building also requires initializing and patching the typescript-go submodule before compiling with Go.

Found this useful?

Share it with someone who would like tsgolint.

Comparisons