TypeScript 6.0 Will Be the Last JavaScript-Based Major Release

Microsoft’s TypeScript team announced that TypeScript 6.0 will be the final major release built on the current JavaScript/TypeScript compiler codebase (the “Strada” line). After 6.0, the focus shifts to finishing TypeScript 7.0, the native port (Project Corsa) that is already shipping as nightly previews for both the compiler and the TypeScript VS Code extension (native preview).

In a progress update published yesterday, Daniel Rosenwasser, a Principal Product Manager on Microsoft’s TypeScript team, describes TypeScript 6.0 as a bridge between the 5.9 line and the upcoming 7.0 native toolchain. The team is not planning a TypeScript 6.1, though they may publish 6.0.x patches in specific high-severity cases.

The stated criteria for post-6.0 servicing is narrow: security issues, high-severity regressions, and high-severity fixes related to 6.0 and 7.0 compatibility.

TypeScript 7’s Native Toolchain is Ready for Testing#

The TypeScript team says the native preview is far enough along for real projects, including in-editor workflows. In the most recent update, previously missing editor features are now back, like auto-imports, find-all-references, and rename, alongside core navigation and IntelliSense.

For builds, the native compiler preview ships on npm as @typescript/native-preview and provides tsgo, a tsc-like CLI designed to run side by side with the existing toolchain.

Type-checking parity is close. In the post, the TypeScript team says the native toolchain produces essentially the same diagnostics as the current compiler in almost all of their test suite, with the remaining gaps tied to known unfinished work or intentional changes.

On the CLI side, they say the native compiler now supports --incremental, project references, and --build mode.

Performance: The Native Compiler is Dramatically Faster#

A large part of the update is about performance and parallelism, backed by benchmark results for the native compiler. They attribute the gains to two things: moving the toolchain to native code and using shared-memory parallelism (not just parallelizing work within a project, but also building multiple projects concurrently in --build setups).

"As we’ve described previously, this comes in part from native code performance, but also from the use of shared-memory parallelism," Rosenwasser said. "More specifically what this means is that not only can TypeScript now do fast multi-threaded builds on single projects; it can now build up multiple projects in parallel as well! Combined with our reimplementation of --incremental, we’re close to making TypeScript builds feel instantaneous for smaller changes in large projects."

The team shared benchmarks that show TypeScript 7 is ~7.5 to ~10x faster full builds:

Expect Breaking Changes Driven by Deprecations#

TypeScript 7.0 is expected to remove behaviors and flags that the team plans to deprecate in TypeScript 6.0. They list examples like --strict becoming the default, --target defaulting to the latest stable ECMAScript target, removing --target es5 (with es2015 as the floor), removing --baseUrl, and removing --moduleResolution node10 in favor of bundler and nodenext.

The team has been experimenting with a config-migration tool (ts5to6) that currently targets baseUrl and rootDir.

The native compiler’s JavaScript emit pipeline is still incomplete and is not yet a drop-in replacement. The post suggests tsgo is a clean fit if you do not rely on TypeScript emit, or if you are targeting modern runtimes, but calls out real limitations for older targets and decorators right now.

Tooling that Depends on the Current Compiler API Will Feel the Gap

TypeScript 7.0 will not support the existing Strada API, and a stable replacement API is still in progress. That means tooling that relies on the current typescript API surface (linters, formatters, IDE extensions, and other integrations) will not work directly with Corsa yet.

The team’s suggested workaround is a split setup: keep typescript for API-dependent tooling, and use @typescript/native-preview (tsgo) for type-checking.

If your codebase relies heavily on JS checking with JSDoc, the post flags that this part of the system has been rewritten and some patterns are no longer recognized, including @enum and @constructor. It also notes the removal of several “relaxed” JS type-checking behaviors, which may increase error counts in some JS codebases.

Try the Native Preview#

If you want to test it, the team points to the VS Code TypeScript (Native Preview) extension and the npm package @typescript/native-preview, which installs a tsgo CLI you can run alongside tsc.

TypeScript 6.0 is being positioned as a compatibility bridge with a higher bar for what lands, while the TypeScript team puts most momentum into getting the native compiler and language service to full parity. For teams, the most realistic near-term use case is to adopt tsgo first as a faster type-checking path (especially in multi-project repos), then expand as emit support and the new API surface stabilize.

"We’ve been able to implement a type-checker with extremely high compatibility," Rosenwasser said. "As a result, projects both inside and outside Microsoft report that they’ve been able to easily use the native compiler with minimal effort. Stability is going well, and we’re on track to finish most language service features by the end of the year. Many teams are already using Corsa for day-to-day work without any blocking issues."