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:

{
  "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:

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

Library Authors: Updating Published Type Declarations

Library authors face a specific challenge with TypeScript 6.0: their published package may work correctly at runtime but produce TypeScript errors in consumers who have upgraded. If your published .d.ts files reference deprecated compiler settings or contain type patterns that TypeScript 6.0 rejects, downstream users will see errors when type-checking imports from your package. The recommended library author checklist includes: run tsc --noEmit --strict with TypeScript 6.0 against your own source, update the tsconfig.json to remove deprecated flags, and republish with updated declaration files. Pinning typescript in your package's devDependencies to >=6.0.0 signals to consumers that your types have been validated against the new release.

Impact on Build Tooling and Downstream Ecosystems

TypeScript 6.0's breaking changes ripple through the ecosystem because major tools build on top of the TypeScript compiler API. esbuild, SWC, and Vite's type-checking integrations must account for the removed flags — configuration options like downlevelIteration that esbuild previously passed through silently now produce errors if your tsconfig.json still contains them when TypeScript 6 validates the config. Most bundler integrations that run tsc --noEmit for type checking are affected: the first CI run after upgrading will surface every deprecated flag in your configuration even if the bundler itself doesn't use them.

The moduleResolution: classic removal has the broadest ecosystem impact because it was the implicit default for projects that omitted the moduleResolution field when module was set to CommonJS. Older libraries that haven't updated their tsconfig.json to explicitly set moduleResolution: node or noderesolution: nodenext will begin failing type-checking when consumers upgrade to TypeScript 6. Library authors should run tsc --noEmit with TypeScript 6 against their own package and patch as needed — otherwise their package will surface errors in downstream projects even if the runtime behavior is correct.

The path toward TypeScript 7.0 (tsgo, the Go-based compiler) means TypeScript 6.0 is effectively the last release where running tsc is synonymous with running the TypeScript compiler. When tsgo ships as stable, projects will need to choose between the JavaScript-based TypeScript 6 (slower, but complete IDE support) and the Go-based TypeScript 7 (10x faster type checking, evolving IDE integration). The --stableTypeOrdering flag in TypeScript 6.0 serves as the bridge: it surfaces any type-ordering dependencies in your codebase that the Go compiler would handle differently, letting you fix them now rather than discovering them when migrating to 7.0.

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.

See also: AVA vs Jest and Mermaid vs D3.js vs Chart.js 2026