TypeScript 7 is the native (Go-based) rewrite of the TypeScript compiler, often called tsgo. Type checking with it is much faster, but tools that need type information, such as linters, could not use it yet. typescript-eslint 8.73.0, released on 16 November 2026, takes the first step: an opt-in, experimental backend that lets typed linting run on the TypeScript 7.1 native parser.
This guide explains what the new EXPERIMENTAL_backend: 'tsgo' option does, how to set it up on a branch, what it does not support yet and what to expect from performance. Sources: the v8.73.0 release, pull request #12803 and the parser documentation.
What is in 8.73.0
The release has three features:
- typescript-estree:
projectService.EXPERIMENTAL_backendfor TypeScript 7.1 native parser support over IPC. - eslint-plugin: a new rule,
no-unsafe-class-instance-assignment. - eslint-plugin:
consistent-type-importsreports on a narrower location.
The tsgo backend is the headline. It is off by default, so upgrading to 8.73 changes nothing unless you opt in.
How the tsgo backend works
Typed lint rules (for example no-floating-promises) ask TypeScript about types, symbols and signatures. Until now, typescript-eslint always talked to the classic JavaScript TypeScript API.
With the tsgo backend, typescript-eslint starts the native TypeScript 7.1 process and talks to it over IPC. It wraps the native API in a “facade” shaped like the classic TypeScript 6.x services, so existing rules keep working. The PR adds adapters for nodes, types, the checker and the program to translate between the two.
Requirements
According to the parser docs, you need:
- A Node.js version that can
require()ES modules: 20.19, 22.12 or newer. - Classic TypeScript 6 installed as
typescript. - A TypeScript 7.1 nightly installed side by side under the alias
@typescript/native, at least7.1.0-dev.20261009.1. - The project service (
parserOptions.projectService), not the legacyprojectoption.
Step 1: Install on a branch
git switch -c try-tsgo-lint
The docs give this pnpm command:
pnpm add --save-dev typescript@^6 @typescript/native@npm:[email protected]
With npm, the same alias syntax works:
npm install --save-dev typescript@^6 "@typescript/native@npm:[email protected]"
Make sure typescript-eslint itself is at 8.73 or newer:
npm install --save-dev typescript-eslint@^8.73.0
Step 2: Turn it on in your ESLint config
// eslint.config.mjs
import tseslint from 'typescript-eslint';
export default tseslint.config(
...tseslint.configs.recommendedTypeChecked,
{
languageOptions: {
parserOptions: {
projectService: {
EXPERIMENTAL_backend: 'tsgo',
},
tsconfigRootDir: import.meta.dirname,
},
},
},
);
Leaving EXPERIMENTAL_backend unset (the default) keeps the classic backend.
A handy trick is to switch backends with an environment variable of your own, so the same config works for both:
const backend = process.env.LINT_BACKEND === 'tsgo' ? 'tsgo' : undefined;
// ...
projectService: { EXPERIMENTAL_backend: backend },
LINT_BACKEND=tsgo npx eslint .
npx eslint .
Step 3: Compare results with the classic backend
Because the backend is experimental, the first job is to check that it reports the same problems. Write both outputs to JSON and compare the counts:
npx eslint . -f json -o lint-classic.json
LINT_BACKEND=tsgo npx eslint . -f json -o lint-tsgo.json
// compare-lint.mjs
import { readFileSync } from 'node:fs';
const count = (file) =>
JSON.parse(readFileSync(file, 'utf8'))
.flatMap((f) => f.messages.map((m) => `${f.filePath}:${m.line}:${m.ruleId}`));
const classic = new Set(count('lint-classic.json'));
const tsgo = new Set(count('lint-tsgo.json'));
console.log('only classic:', [...classic].filter((x) => !tsgo.has(x)));
console.log('only tsgo:', [...tsgo].filter((x) => !classic.has(x)));
Any difference is worth a look, and worth reporting upstream if it looks like a bug.
What is not supported yet
The docs list these limits for the tsgo backend:
- No legacy
parserOptions.projectorparserOptions.programs. UseprojectService. - Not yet:
parserOptions.extraFileExtensions. - Not yet: the
allowDefaultProject,defaultProject,loadTypeScriptPluginsandmaximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTINGproject service options.
Known differences from classic TypeScript:
- A file that a project only includes through a symlinked path is not found by its real path.
- Boolean literal types have a
valueproperty. - JavaScript constructor functions are not treated as classes.
If your shared config sets extraFileExtensions (common for Vue or Svelte setups), keep those projects on the classic backend for now.
Performance: not faster yet
It is tempting to assume “native” means “faster lint”, but not yet. In the PR’s benchmark on an M1 Max, the native backend ranged from about 0.86x to 1.72x the time of classic, depending on project size and rule set. Light rule sets like no-floating-promises were roughly even. The heavy recommendedTypeChecked set got slower as projects grew, up to about 1.72x at 8,192 files, with higher memory use too.
The author explains why: TypeScript 7.1 computes types much faster, but each question a rule asks is a synchronous round trip to the separate tsgo process, and TypeScript 7.1 does not yet have all the bulk APIs typescript-eslint wants. The PR already adds batching, caching and prefetching, and the team expects performance to improve significantly once those APIs exist.
So today, the reason to try tsgo is compatibility testing, not speed.
The new rule in 8.73
Besides the backend, 8.73 adds the no-unsafe-class-instance-assignment rule to @typescript-eslint/eslint-plugin. Like other new rules, it is not switched on for you automatically unless a preset you use includes it, so read its documentation page and enable it explicitly if it fits your codebase:
rules: {
'@typescript-eslint/no-unsafe-class-instance-assignment': 'error',
},
Should you use it?
- Production CI: not yet. Keep the classic backend.
- A branch or a nightly CI job: yes, if you plan to move to TypeScript 7. Finding differences early helps you and the project.
- Editor use: try it, but expect rough edges; the feature is clearly marked experimental.
Takeaway
typescript-eslint 8.73 makes typed linting on TypeScript 7.1’s native compiler possible for the first time, behind projectService.EXPERIMENTAL_backend: 'tsgo'. Set it up on a branch with TypeScript 6 and a 7.1 nightly side by side, compare results with the classic backend, and keep production CI on classic until the bulk APIs land and the option loses its “experimental” label.
