--- og_image: "/images/guides/typescript-6-final-2026.webp" title: "TypeScript 6.0 Final: Breaking Changes 2026" description: "TypeScript 6.0 shipped March 23, 2026 as the last JavaScript-based release before Go-native TS 7.0. Breaking changes and migration steps to upgrade from 5.x." date: "2026-03-26" author: "PkgPulse Team" tags: ["typescript", "typescript-6", "migration", "javascript", "compiler"] --- # 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: This final guide is now the canonical TypeScript 6 reference for PkgPulse; the older RC coverage is kept only for historical context and redirects here. 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: ```json { "compilerOptions": { "target": "ES5" } } ``` You'll get: ``` error TS5023: Unknown compiler option 'ES5'. ``` **Fix:** Upgrade target to ES2015 or higher: ```json { "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: ```json { "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"` | ```json { "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. ```json // 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: ```typescript // 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. ```json // 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: ```typescript // 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: ```json { "compilerOptions": { "target": "ES2025", "lib": ["ES2025", "DOM"] } } ``` ### `--stableTypeOrdering` Migration Flag This flag helps you prepare for TypeScript 7.0 (Go-based): ```bash 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: ```bash 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+: ```json { "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: ```json { "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: ```json { "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 ## 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](/guides/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](/guides/zod-v4-vs-arktype-vs-typebox-vs-valibot-schema-2026).* *See also: [AVA vs Jest](/compare/ava-vs-jest) and [Mermaid vs D3.js vs Chart.js 2026](/guides/mermaid-vs-d3-vs-chartjs-diagrams-data-visualization-2026)*