TypeScript 6.0 Is Here — And It's the Last One Built in JavaScript

TypeScript 6.0 has landed, and if you've been waiting to upgrade, there's a lot to unpack — starting with the fact that this is the last TypeScript compiler ever written in TypeScript itself. Microsoft is rewriting the entire toolchain in Go for version 7.0, and the early benchmarks are jaw-dropping: the VS Code codebase that takes 77.8 seconds to compile today drops to just 7.5 seconds.

What Changed in TypeScript 6.0

TypeScript 6.0 is a breaking-change release by design. The most significant shift is that strict mode is now on by default — meaning any project that hasn't explicitly opted in to strict checking will see new errors on upgrade. This is a long-overdue change that aligns TypeScript's defaults with how almost every serious project already configures it, but it will break existing codebases that relied on lenient defaults.

The other headline changes:

• The module compiler option now defaults to esnext instead of commonjs, and target defaults to ES2025.
• dom.iterable and dom.asynciterable are merged into the base dom lib — you no longer need to list them separately in your lib array.
• The legacy namespace and module keyword syntax (the old non-ES-module style) is now a hard error, not just a deprecation warning.
• New built-in types ship for the Temporal API, RegExp.escape(), and Map.prototype.getOrInsert() — all stage-4 proposals that are landing in modern runtimes.

Microsoft also added a --stableTypeOrdering flag specifically to help teams identify behavioral differences between 6.0 and the upcoming 7.0 Go-based compiler, signaling that they're thinking carefully about migration tooling.

The Big Picture: TypeScript 7.0 Is a Ground-Up Go Rewrite

The real story behind TypeScript 6.0 is what it makes room for. TypeScript 7.0 — codenamed Project Corsa — rewrites the entire compiler in Go, and the performance numbers are staggering. Microsoft benchmarked the VS Code repository (one of the largest TypeScript projects in existence) and measured a 10x build-speed improvement: what takes 77.8 seconds today completes in 7.5 seconds with the native Go compiler.

This isn't just a performance story. The Go-based compiler ships as a native binary with no Node.js dependency. That means language server startup times drop dramatically, CI pipelines no longer need Node.js installed just for type-checking, and editor integrations become more reliable across environments. If you want to experiment today, Microsoft has published nightly builds as an npm package:

npm install -D @typescript/native-preview

The native preview is not production-ready — it's still passing through the full TypeScript test suite — but the team is targeting stability later in 2026. The Go source is open at microsoft/typescript-go on GitHub if you want to follow the work directly.

What You Need to Do Before Upgrading

Upgrading to TypeScript 6.0 from 5.x requires an audit pass before you flip the version number. Start with strict mode: run tsc --strict against your 5.x codebase first and triage the new errors before committing to the upgrade. Most issues will be around implicit any parameters and missing null checks in optional chaining.

Module resolution is the other major friction point. If your project outputs CommonJS — Node.js libraries, legacy server code — explicitly set "module": "commonjs" in your tsconfig.json, because the new default of esnext will break your output format silently. Similarly, if you have any namespace blocks in your codebase, now is the time to migrate them to standard ES module export syntax; the namespace form is finally treated as a compile error.

For teams running large monorepos, Microsoft's guidance is to run tsc --stableTypeOrdering to baseline your type errors before the 7.0 Go compiler lands. Internal type resolution order can differ slightly between the JavaScript and Go implementations, and getting ahead of those diffs now saves pain later.

The Bottom Line

TypeScript 6.0 closes out a decade of incremental defaults and positions the ecosystem for the most fundamental toolchain change since TypeScript's creation. The Go rewrite in 7.0 isn't a rewrite of the language — it's a rewrite of the compiler infrastructure, and the speed gains alone will change how teams think about type-checking in CI. Upgrade to 6.0 now, triage the breaking changes, and you'll be in the best shape to ride the wave when 7.0 ships.