TypeScript 6.0: Breaking Changes and Migration Guide

TypeScript 6.0 shipped May 8 and it deserves your attention — not because of the new features, but because of what it removes. This is the last version of TypeScript compiled by TypeScript itself. Starting with 7.0, the compiler is being rewritten in Go (Project Corsa is already in beta). That makes 6.0 a mandatory cleanup release: nine default settings changed at once, legacy module systems are gone, and strict: true is now on whether you asked for it or not. Teams who upgrade without preparation will hit a wall of errors. Teams who prep first get tangible build time wins today.

Nine Defaults Changed at Once

This is where most teams will feel the pain. TypeScript 6.0 didn’t just add features — it updated the out-of-the-box config significantly:

• strict: true is now default. If your tsconfig.json never explicitly set this, every type shortcut you’ve taken for years is now an error. Expect null checks, implicit any complaints, and strictPropertyInitialization failures across the board.
• types: [] (empty by default). TypeScript no longer auto-discovers @types packages. You must list them explicitly: "types": ["node", "jest"]. The benefit is real — cold builds drop 20-50% — but if you don’t update your config, globally-available types simply vanish.
• module defaults to esnext, moduleResolution to bundler. CommonJS-first projects will need to explicitly set these or face module resolution surprises.
• rootDir defaults to the current directory, not inferred from source file locations. Add "rootDir": ".\/src" if you relied on inference.
• DOM.Iterable is now bundled into DOM, so remove it from your lib array to avoid duplication warnings.

The practical read: if your tsconfig is already disciplined — strict enabled, modern module resolution, explicit types — upgrading is painless. If your project has lived for years on implicit defaults and legacy patterns, run the migration tooling before touching the version number.

Hard Removals: Some Options Are Just Gone

TypeScript 6.0 drew a firm line on legacy module systems. These aren’t deprecations — they throw compiler errors:

• module: "amd", "umd", "systemjs", "none" — removed
• --outFile — removed entirely
• moduleResolution: "classic" and the old "node" (node10) — gone
• baseUrl as a module resolution root — deprecated; fold it into explicit paths
• target: "es5" — deprecated (ES2015 is the new floor)

If you’re still bundling with AMD in 2026, TypeScript just forced your hand. The ESM transition that has been “coming soon” for five years is now mandatory. There’s no polite deprecation path for these — just compiler errors.

How to Migrate Without Breaking Everything

The TypeScript team provided a clear escape valve: "ignoreDeprecations": "6.0" in your compilerOptions will suppress deprecated-option errors temporarily. Use it to buy time, not as a long-term solution — TypeScript 7.0 removes this entirely.

The fastest path to a clean TypeScript 6.0 config:

{
  "compilerOptions": {
    "module": "nodenext",
    "moduleResolution": "nodenext",
    "lib": ["ES2025", "DOM"],
    "paths": { "@utils/*": ["./src/utils/*"] },
    "types": ["node"],
    "strict": true,
    "outDir": "./dist"
  }
}

For large codebases, the ts5to6 codemod automates most tsconfig changes. Run it first, review the diff, then fix any remaining strict-mode errors manually.

Why 6.0 Had to Clean House: The Go Compiler Is Coming

TypeScript 7.0 (Project Corsa) rewrites the entire compiler in Go. The performance numbers are not incremental improvements — they’re generational:

• VS Code (1.5 million lines): 77.8s → 7.5s — 10.4x faster
• TypeORM: 17.5s → 1.3s — 13.5x faster
• Playwright: 11.1s → 1.1s — 10.1x faster
• Memory usage: 2.9x lower across the board

The Go port preserves TypeScript’s type system exactly — the team used the same 20,000 test cases and found only 74 discrepancies. TypeScript 6.0’s aggressive default cleanup removes a decade of legacy options before Go takes over, ensuring the new compiler doesn’t have to support patterns that complicate both correctness verification and performance tuning.

TypeScript 7.0 is available now in preview via npm install @typescript/native-preview. The stable release is expected in late 2026 or early 2027. If you want to see the speedup for yourself, the Project Corsa repository is public.

New Language Features in 6.0

Not everything is removals. TypeScript 6.0 adds type support for several recently-stabilized JavaScript APIs:

• Temporal API — full type coverage for the long-awaited date/time replacement (requires esnext target)
• Map.getOrInsert() / getOrInsertComputed() — typed correctly now
• RegExp.escape() — safe regex string construction, finally typed
• Node.js subpath imports with #/ — eliminates path aliasing workarounds for pure Node projects
• ES2025 target support — access to Promise.try() and new Set operation methods

Should You Upgrade Now?

Yes — with preparation. The migration is well-documented and the tooling (ts5to6 codemod, ignoreDeprecations escape hatch) makes it manageable. Waiting doesn’t help: the deprecated options will be fully removed in TypeScript 7.0, and the ignoreDeprecations flag won’t work there. Every month you delay on a legacy config is a month of compounding technical debt before the Go compiler ships.

Check the official TypeScript 6.0 announcement for the full changelog, and use the complete migration guide to walk through every affected option. The Go rewrite is not science fiction — it’s already running in VS Code’s nightly builds. TypeScript 6.0 is the last cleanup before it lands.