TypeScript 6.0: What's New, Breaking Changes & Upgrade

Quick answer. TypeScript 6.0 shipped on March 23, 2026. It’s the last release built on the JavaScript-based compiler and a deliberate bridge to TypeScript 7 — a from-scratch rewrite in Go that is roughly 10× faster. 6.0 flips several defaults on (strict mode, ESM modules, an es2025 target) and removes a batch of legacy options, so the main reason to upgrade now is to absorb those breaking changes before the jump to 7.0.

If you searched for the latest version of TypeScript, this is it: TypeScript 6.0, generally available since March 2026. It’s an unusual release — not a big bag of new syntax, but a carefully-scoped cleanup that sets up the most significant change in TypeScript’s history: a compiler rebuilt in Go. Here’s what’s new, what breaks, and whether you should upgrade.

What is TypeScript 6.0?

TypeScript 6.0 is, in Microsoft’s own words, “the last release based on the current JavaScript codebase.” For more than a decade the TypeScript compiler (tsc) has been written in TypeScript itself. The team is now rewriting it in Go — a project codenamed Corsa — to take advantage of native code and multi-threading. That native compiler becomes TypeScript 7.0.

So 6.0’s job is to be a clean on-ramp. Most of its changes exist to align the current compiler with how 7.0 will behave, so that code which compiles cleanly under 6.0 compiles identically under 7.0. Going forward, the 6.0 line will only receive patch releases for security and critical regressions.

When was TypeScript 6.0 released?

Stage	Date
Beta	February 11, 2026
Release Candidate	March 6, 2026
Stable (GA)	March 23, 2026

What’s new in TypeScript 6.0?

The headline additions are pragmatic rather than flashy:

--stableTypeOrdering — a new flag that makes type ordering deterministic to match TypeScript 7.0, so you can diff output between the current and Go-based compilers during migration. It can slow builds noticeably, so it’s a migration aid, not a production default.
es2025 as a target and lib — type definitions for the APIs that shipped in ES2025, and the default target now floats to the most recent supported ECMAScript year (currently es2025).
Temporal API types — available via esnext, covering the modern date/time API.
RegExp.escape and Map/WeakMap upsert methods (getOrInsert, getOrInsertComputed) added to the lib definitions.
--moduleResolution bundler broadened — now valid alongside commonjs, and positioned as the recommended upgrade path away from the deprecated node resolution.
Node.js subpath imports (paths starting with #/) supported under nodenext and bundler.
DOM lib consolidation — the dom lib now includes dom.iterable and dom.asynciterable.

What breaks in TypeScript 6.0?

This is the part to plan for — 6.0 carries the largest set of breaking changes in years. Several defaults flip on, and a number of legacy options are removed outright.

Defaults that changed

Option	New default
`strict`	`true` (was false)
`module`	`esnext` (was commonjs)
`target`	`es2025` (floats to latest)
`types`	`[]` — no longer auto-includes every `@types` package
`rootDir`	the directory containing `tsconfig.json`
`noUncheckedSideEffectImports`	`true`

Removed outright

--module amd, umd, systemjs, and none
--moduleResolution classic
--outFile
The /// <reference no-default-lib="true"/> directive
You can no longer set esModuleInterop or allowSyntheticDefaultImports to false

Deprecated (still works, warns)

target: es5 and --downlevelIteration
--moduleResolution node (the old node10 behavior)
--baseUrl as a module-resolution root
The legacy module keyword for namespaces (use namespace)
assert import attributes (use with instead)

One behavioral gotcha worth flagging for CI scripts: passing file arguments to tsc while a tsconfig.json exists now errors. Add --ignoreConfig if you intentionally compile single files.

How does TypeScript 6.0 relate to TypeScript 7 (the Go rewrite)?

This is the real story. TypeScript 7.0 is the compiler and language service rebuilt in Go, and the performance numbers Microsoft has published are dramatic — note that these belong to 7.0, not 6.0:

The VS Code codebase (~1.5M lines): type-check time dropped from about 77 seconds to 7.5 seconds — roughly 10×.
Comparable ~8–13× speedups on Playwright, TypeORM, and other large projects.
Editor load times (the language service) improved by a similar margin, which is what most developers actually feel day to day.

The native compiler ships as the @typescript/native-preview package. TypeScript 7.0 reached Release Candidate on June 18, 2026, with the team aiming to ship the stable release within about a month — so by the time you read this, 7.0 is essentially here. Microsoft summarizes it plainly: “TypeScript 7.0 is often about 10 times faster than TypeScript 6.0.”

TypeScript 6.0 is the bridge. Adopt it, clean up the deprecations, and the move to the Go-based 7.0 should be close to seamless.

How to upgrade to TypeScript 6.0 safely

Treat 6.0 as the on-ramp to 7.0 and migrate deliberately:

Upgrade and run a build. Install TypeScript 6.0 and compile. Because strict, module: esnext, and target: es2025 are now defaults, expect new errors and emit changes on projects that relied on the old loose defaults.
Pin the defaults you depend on. If you ship CommonJS or aren’t ready for strict mode, set module, target, and strict explicitly in tsconfig.json rather than inheriting the new values.
List your @types packages. With types defaulting to an empty array, add the ambient type packages you actually use (for example ["node"]).
Migrate off removed and deprecated options. Move --moduleResolution node to bundler (or nodenext), drop --outFile and the AMD/UMD/SystemJS module formats, and replace assert import attributes with with.
Validate against 7.0. Turn on --stableTypeOrdering and get a clean compile without relying on the ignoreDeprecations escape hatch. If that passes, your code should behave identically on the Go-based TypeScript 7.0.

Want the full picture? Read our continuously-updated Cursor IDE complete guide — how AI editors handle large TypeScript codebases, and where the 10× faster language service changes the workflow

Building fast and short on engineers?

Codersera connects you with vetted remote TypeScript and full-stack engineers who can handle a major version migration without slowing your roadmap.

Hire vetted remote developers →

FAQ

What is the latest version of TypeScript?

TypeScript 6.0, generally available since March 23, 2026, is the latest stable release. TypeScript 7.0 — the Go-based rewrite — reached Release Candidate on June 18, 2026 and is shipping shortly after.

Is TypeScript 6.0 a big update?

In features, no — it’s a focused cleanup. In impact, yes: it flips major defaults on (strict, ESM, es2025) and removes legacy options, making it the largest set of breaking changes in years and the required stepping stone to TypeScript 7.0.

Why is TypeScript being rewritten in Go?

To make it dramatically faster. A native Go compiler with multi-threading delivers roughly 10× faster type-checking and editor responsiveness compared with the JavaScript-based compiler. That rewrite becomes TypeScript 7.0.

Will my TypeScript 6.0 code work in TypeScript 7.0?

That’s the design goal. Code that compiles cleanly under 6.0 — with --stableTypeOrdering on and without the ignoreDeprecations flag — should compile identically under 7.0.

Should I upgrade to TypeScript 6.0 now?

Yes, in most cases. Upgrading on the stable JavaScript-based compiler lets you absorb the breaking changes at your own pace before the switch to the Go-based 7.0, rather than facing everything at once.