TypeScript 7: what the native compiler changes in practice

TypeScript 7.0 is the compiler rewritten in Go. Microsoft reports full-build speedups in the range of 8x to 12x on large codebases (for example, VS Code going from about 126 seconds to about 11 seconds). The type system is a faithful port, so the same code should produce the same errors.

What stays the same

The package is still typescript, the command is still tsc, and the language is unchanged. The experimental tsgo name from 2025 now lives only in the nightly @typescript/native-preview channel.

1npm install --save-dev typescript@latest
2npx tsc --version
3npx tsc --noEmit

Where you will feel it

CI. Type-checking is usually the slowest step of a frontend pipeline. A 10x faster tsc --noEmit often removes the need to split checks across jobs or cache build info.

Editors. Language service operations such as find references and rename are faster, which matters most in monorepos.

Scripts. Anything you previously skipped because "typecheck takes too long" in a pre-push hook becomes viable again.

1{
2  "scripts": {
3    "typecheck": "tsc --noEmit",
4    "prepush": "npm run typecheck && npm run lint"
5  }
6}

What to check before upgrading

• Deprecated options are gone. Anything you silenced with ignoreDeprecations: "6.0" stops working. Migrate on 6.0 first.
• The compiler API changed. The old JavaScript API is not available in the native compiler, and a replacement is still being finalized. Tools that import typescript programmatically (custom lint rules, codegen, some bundler plugins) may need updates. Check each tool's release notes.
• Verify your toolchain. Run your build, tests and lint on a branch and compare diagnostics against 6.0.

A pragmatic rollout

1. Get to a clean build on TypeScript 6.0 with no deprecation warnings.
2. Install 7.0 on a branch and run the full CI pipeline.
3. Diff the diagnostics. They should match; investigate any that do not.
4. Merge, then tighten CI by removing workarounds that existed only because checks were slow.

The practical win is not a benchmark number. It is that type-checking stops being something the team plans around.

Sources and further reading

• Microsoft: A 10x Faster TypeScript