TypeScript 6.0 Final: Breaking Changes 2026

TL;DR

TypeScript 6.0 shipped on March 23, 2026 — and it's a milestone release in two ways. First, it's the last TypeScript release built on JavaScript. The team is now full-speed on TypeScript 7.0 written in Go (tsgo), which will be 10x faster. Second, it's a spring cleaning release: deprecated flags removed, module resolution tightened, ES5 target dropped, and strict mode changes that will break old codebases. If you're running TypeScript 5.x, your upgrade path starts here.

Key Takeaways

• Last JS-based TypeScript — TypeScript 6.0 clears the path for the Go-native TypeScript 7.0
• ES5 and ES3 targets removed — minimum supported target is now ES2015
• moduleResolution: classic removed — migrate to nodenext or bundler
• --downlevelIteration removed — strip it from your tsconfig.json
• Strict mode universal — TypeScript 6.0 unconditionally emits "use strict" in non-ESM files
• New --stableTypeOrdering flag — bridges output compatibility with the upcoming Go compiler
• ES2025 lib target added — new standard library type definitions for ES2025 built-ins

---

What's New in the Final vs the RC

The TypeScript 6.0 RC (March 6, 2026) and the final release (March 23, 2026) are close — Microsoft confirmed three post-RC changes in the final:

1. Additional strict mode reserved identifiers — implements, interface, let, package, private, protected, public, static, and yield are now reserved in non-module, non-strict contexts. Using any of these as variable names will produce a compile error.

2. --stableTypeOrdering flag finalized — The flag's behavior was adjusted to exactly match how the Go-based TypeScript 7.0 checker orders types, ensuring your migration output comparison is reliable.

3. Two additional deprecated flag removals — --noImplicitUseStrict and --suppressImplicitAnyIndexErrors were removed in the final (they were deprecated in RC but not yet removed).

---

Breaking Changes You Need to Fix

1. ES5 and ES3 Targets Removed

This is the most common break in existing codebases. If your tsconfig.json has:

{
  "compilerOptions": {
    "target": "ES5"
  }
}

You'll get:

error TS5023: Unknown compiler option 'ES5'.

Fix: Upgrade target to ES2015 or higher:

{
  "compilerOptions": {
    "target": "ES2020"   // or ES2022, ES2023, ES2024, ES2025
  }
}

If you were targeting ES5 for IE11 support — IE11 is long dead. ES2020 is supported in every browser and Node.js 14+. For legacy bundlers that transpile for you anyway, "target": "ES2020" is the right call since your bundler handles the actual output.

2. moduleResolution: classic Removed

Classic resolution predates Node.js module semantics and has been deprecated since TypeScript 4.x. If you have:

{
  "compilerOptions": {
    "moduleResolution": "classic"
  }
}

Fix: Migrate to the appropriate modern setting:

Context	Setting
Node.js projects (CJS/ESM)	"moduleResolution": "nodenext"
Bundler projects (Vite, webpack, esbuild)	"moduleResolution": "bundler"
Libraries targeting multiple environments	"moduleResolution": "bundler"

{
  "compilerOptions": {
    "moduleResolution": "bundler",
    "module": "ESNext"
  }
}

3. --downlevelIteration Removed

This flag enabled accurate iteration over iterables like Map, Set, and generator functions when targeting ES5 (which no longer exists). With ES5 target gone, the flag is meaningless.

// BEFORE (breaks in TS 6.0)
{
  "compilerOptions": {
    "target": "ES5",
    "downlevelIteration": true
  }
}

// AFTER
{
  "compilerOptions": {
    "target": "ES2020"
    // downlevelIteration gone — not needed
  }
}

4. Strict Mode Identifiers

TypeScript 6.0 unconditionally emits "use strict" in non-ESM output files. This means strict mode reserved words become compile errors if used as identifiers:

// These NOW error in TypeScript 6.0:
const let = 5;        // error: 'let' is a reserved word in strict mode
function static() {}  // error: 'static' is a reserved word in strict mode
const package = {};   // error: 'package' is a reserved word in strict mode

Full list of newly reserved identifiers: implements, interface, let, package, private, protected, public, static, yield.

Fix: Rename variables/functions that use these identifiers.

5. --noImplicitUseStrict and --suppressImplicitAnyIndexErrors Removed

Both flags are gone in the final release.

// Remove these lines if present:
{
  "compilerOptions": {
    "noImplicitUseStrict": false,         // ❌ remove
    "suppressImplicitAnyIndexErrors": true // ❌ remove
  }
}

---

New Features

ES2025 Target and Lib

TypeScript 6.0 adds es2025 to both target and lib. There are no new JavaScript syntax features in ES2025, but there are new built-in APIs with proper type definitions:

// New in ES2025 lib:
const set = new Set([1, 2, 3, 4]);
const union = set.union(new Set([3, 4, 5]));   // Set.prototype.union
const inter = set.intersection(new Set([3, 4])); // Set.prototype.intersection
const diff = set.difference(new Set([3]));        // Set.prototype.difference

// New Map grouping:
const grouped = Map.groupBy([1, 2, 3, 4], n => n % 2 === 0 ? 'even' : 'odd');

To use these types, update your tsconfig:

{
  "compilerOptions": {
    "target": "ES2025",
    "lib": ["ES2025", "DOM"]
  }
}

--stableTypeOrdering Migration Flag

This flag helps you prepare for TypeScript 7.0 (Go-based):

tsc --stableTypeOrdering

TypeScript 7.0's parallel type checker visits nodes in a deterministic order based on content (not encounter order). If your code has types that differ based on ordering (common in union/intersection types with side effects), this flag will surface those differences now.

When to use it:

• Run it before migrating to TypeScript 7.0
• Compare output between tsc and tsgo to find ordering-dependent behavior
• Not needed in production builds — only for migration auditing

---

Migration Checklist: TypeScript 5.x → 6.0

□ Update TypeScript: npm install typescript@6 -D
□ Remove "target": "ES5" or "ES3" → replace with "ES2020" or higher
□ Remove "moduleResolution": "classic" → replace with "bundler" or "nodenext"
□ Remove "downlevelIteration": true
□ Remove "noImplicitUseStrict" (any value)
□ Remove "suppressImplicitAnyIndexErrors" (any value)
□ Search codebase for: let, static, package, implements, interface used as identifiers → rename
□ Run tsc --noEmit to surface remaining errors
□ Optionally run tsc --stableTypeOrdering to prep for TS 7.0

Automated fixes with ts-migrate

The TypeScript team's ts-migrate tool handles most of the mechanical changes:

npx ts-migrate migrate --config tsconfig.json

# Or with the TypeScript 6 codemod (if your project uses @typescript/codemod):
npx @typescript/codemod ts6-migration

---

What This Means for the Ecosystem

Node.js + TypeScript Projects

Most Node.js projects will need the moduleResolution change. The new recommended config for Node.js 20+:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "lib": ["ES2022"],
    "strict": true,
    "outDir": "dist"
  }
}

Vite / Bundler Projects

For frontend projects using Vite, webpack, esbuild, or Rollup:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "strict": true,
    "noEmit": true   // let the bundler handle output
  }
}

Library Authors

For npm packages targeting multiple environments:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "declaration": true,
    "strict": true
  }
}

---

TypeScript 6.0 vs TypeScript 7.0 (tsgo)

TypeScript 6.0 is a transitional release — the bridge between the JavaScript-based compiler and the upcoming Go-based TypeScript 7.0. Here's what to expect:

	TypeScript 6.0 (now)	TypeScript 7.0 (tsgo)
Language:	JavaScript	Go
Status	Released (March 23, 2026)	In active development
Type check speed	Baseline	~10x faster
IDE integration	Full	Work in progress
Breaking changes	Significant (ES5 removal, etc.)	Minimal (TS 6.0 prepares the way)
Production ready	Yes	Not yet

Bottom line: Upgrade to TypeScript 6.0 now. Fix the breaking changes. Run --stableTypeOrdering to surface type-ordering issues. Then when TypeScript 7.0 ships, your migration should be much smoother.

---

Recommendations

Upgrade now if:

• You're on TypeScript 5.x and don't use target: ES5 or moduleResolution: classic
• You want ES2025 type definitions
• You want to prepare for TypeScript 7.0 (tsgo)

Take more time if:

• Your project has thousands of files with static, let, or other strict-mode reserved identifiers used as variable names — budget time for the rename
• You're maintaining an older codebase that heavily relied on downlevelIteration for IE11-era compatibility

Methodology

• Sources: TypeScript 6.0 official announcement (devblogs.microsoft.com, March 23 2026), TypeScript 6.0 RC announcement (March 6 2026), privatenumber TypeScript 5.x to 6.0 Migration Guide (GitHub Gist), Visual Studio Magazine coverage, TypeScript GitHub issue #62508 (migration guide), JavaScript in Plain English (TypeScript 6.0 What's New)
• Data as of: March 2026

---

Running tsgo (TypeScript 7.0 Go compiler) already? See tsgo vs tsc: TypeScript 7 Go Compiler 2026.

Comparing TypeScript validation libraries that work with TypeScript 6? See Zod v4 vs Valibot vs ArkType 2026.