TypeScript 6.0 & the Go Rewrite: What Changes

Your CI pipeline is about to break. Not because your code is wrong — because TypeScript 6.0 changed defaults that were untouched since 2012. And somewhere further down the road, the compiler you have been running your entire career is being rewritten in Go.

This is not a minor version bump. This is the biggest shift in TypeScript's history, happening in two waves. Here is what you need to know, what you need to change, and why it is actually great news.

TypeScript 6.0: The End of an Era (for Defaults)

TypeScript 6.0 RC landed on March 6, 2026. The headline: it is the last JavaScript-based version of the compiler. TypeScript 7.0, already in preview inside Visual Studio 2026, is a full rewrite in Go.

But TS 6.0 has breaking changes of its own that will hit you before the Go story even matters.

The New Defaults That Will Break Your Build

The TypeScript team has been conservative about defaults for years — target: "ES3" stayed the default for over a decade even as browsers moved on. That era is over.

These defaults are not arbitrary — they reflect the actual environment most TypeScript code runs in today. But if you have an implicit tsconfig.json with no explicit target or module fields, the silent upgrade will change your output.

What breaks in practice

CommonJS libraries: if you publish an npm package with no module override and your toolchain expects CJS output, you will get ESM output. Consumers that do require() your package will throw.

Old Node.js versions: ES2023 output uses features like Array.prototype.findLast, Object.hasOwn, and structured cloning. If you target Node 14 or 16, you need to pin target explicitly.

Class field initialization order: useDefineForClassFields: true aligns with TC39 semantics. Decorators and Angular users will feel this immediately if they have not already migrated.

Migration Guide: Lock Down Your tsconfig Now

The safest upgrade path is to be explicit before you update TypeScript. Do not let 6.0 infer new defaults from a tsconfig that was written assuming old ones.

Before upgrading — run this audit

# Check what TS version you are on
npx tsc --version
 
# Dry-run to see what would change
npx tsc --noEmit --listFiles 2>&1 | head -20

The minimal "preserve TS 5 behavior" tsconfig

If you need continuity and cannot touch output right now:

{
  "compilerOptions": {
    "target": "ES2017",
    "module": "CommonJS",
    "moduleResolution": "node",
    "useDefineForClassFields": false,
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "./dist"
  }
}

The "embrace 6.0" tsconfig for modern apps

For a Next.js or Vite project running on modern Node and targeting modern browsers:

{
  "compilerOptions": {
    "target": "ES2023",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "lib": ["ES2025", "DOM", "DOM.Iterable"],
    "allowImportingTsExtensions": true,
    "noEmit": true,
    "strict": true,
    "verbatimModuleSyntax": true,
    "isolatedModules": true
  }
}

Note the lib: ["ES2025"] — TS 6.0 ships ES2025 lib types alongside the ES2023 target default. These are separate concerns: lib controls what type definitions are available, target controls what syntax the compiler emits.

For library authors

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "strict": true,
    "outDir": "./dist"
  }
}

NodeNext is still the correct choice for packages that need to support both CJS and ESM consumers via dual package exports. Do not use ESNext + bundler resolution in a published library.

Temporal API Types: Finally in TS 6.0

One genuinely useful addition in 6.0: Temporal API types are now included in the standard lib. Temporal is the long-awaited replacement for the broken Date object, and it reached Stage 4 in TC39.

// No more @js-temporal/polyfill types needed
// Include "ES2025" in your lib and you get this for free
 
const now = Temporal.Now.plainDateTimeISO();
console.log(now.toString());
// "2026-04-08T14:32:10.123456789"
 
// Proper timezone-aware instant
const meeting = Temporal.ZonedDateTime.from({
  timeZone: "America/New_York",
  year: 2026,
  month: 4,
  day: 15,
  hour: 10,
});
 
// Duration arithmetic that actually works
const sprint = Temporal.Duration.from({ weeks: 2 });
const deadline = meeting.add(sprint);
 
// Compare dates without the Date.getTime() hack
const isAfterNow =
  Temporal.ZonedDateTime.compare(
    deadline,
    Temporal.Now.zonedDateTimeISO("America/New_York")
  ) > 0;

If you have been using the @js-temporal/polyfill package and its type definitions, you can drop the types package once you move to lib: ["ES2025"]. Keep the runtime polyfill until your target environments ship native Temporal support (V8 and SpiderMonkey are ahead of Safari here).

TypeScript 7.0: The Go Rewrite

Here is the part that actually matters for the next five years.

Microsoft is rewriting the TypeScript compiler in Go. Anders Hejlsberg — the man who created TypeScript, and before that, Delphi and C# — is leading the project. A native preview is already shipping inside Visual Studio 2026.

The numbers: ~8x faster project load times. Compilation speed improves proportionally. For large monorepos where tsc currently takes 30–60 seconds, you are looking at 4–8 second cold builds.

Why Go and not Rust?

The TypeScript team evaluated both. Go won for a specific reason: the TS compiler is deeply recursive and heavily pointer-based. Go's GC and its natural support for graph-like data structures made the port more mechanical. Rust would have required fighting the borrow checker on data structures that mutate in place throughout the type-checking pipeline.

This is the same pattern playing out across the JS tooling ecosystem:

• Biome: rewrote ESLint + Prettier in Rust — 10–100x faster
• SWC: rewrote Babel in Rust — 20x faster
• esbuild: written in Go by Evan Wallace — 10–100x faster than webpack
• Rolldown: Vite's new bundler in Rust

The lesson: JavaScript tools written in JavaScript hit a ceiling. Native compilers win on large codebases. The TypeScript team is acknowledging this reality for their own tool.

What does NOT change

This is critical: the TypeScript language is not changing. The Go rewrite is a compiler port, not a language redesign.

• TypeScript syntax: identical
• Type system semantics: identical
• .d.ts output: identical
• tsconfig.json format: identical
• IDE integration (LSP): will get faster, same protocol

You will not rewrite a single line of TypeScript because of this. You will just wait less for your build.

What does change

The compiler is no longer written in TypeScript itself. This has historically been a point of pride — TypeScript is bootstrapped, meaning it compiles itself. The Go port breaks that property. For the vast majority of developers, this is irrelevant. For the handful of people who contribute to the TypeScript compiler source, it means learning Go.

The npm package will ship precompiled native binaries, similar to how esbuild, SWC, and Biome distribute platform-specific executables. Expect a @typescript/native package pattern, similar to @biomejs/biome.

Language server performance: the LSP that powers VS Code, Neovim, WebStorm and every other editor will run on the Go binary. Editor startup on large projects, go-to-definition latency on deep type chains, rename refactors across 500-file repos — all of these improve.

TypeScript 5 vs 6 vs 7: The Full Picture

What This Means for Your Stack Today

If you use Next.js: the framework handles TS compilation through SWC, not tsc. Type checking (tsc --noEmit) is where you feel the pain on large projects. TS 7.0 makes tsc fast enough that you might stop offloading type checking to separate CI steps.

If you use Vite: same story. Vite uses esbuild for transpilation and ignores type errors at build time. vue-tsc or tsc --noEmit in your pre-push hook will dramatically speed up.

If you use Angular: the Angular compiler uses the TS compiler APIs directly. The Angular team will need to update to the new Go-based APIs. Expect a migration period similar to what happened with Ivy.

If you maintain a TypeScript library: audit your tsconfig.json defaults before the 6.0 upgrade. Set target and module explicitly. Run your test suite. Publish a 5.x-compatible version before bumping peer deps.

If you work in a large monorepo: this is where TS 7.0 changes your life. Teams running Turborepo or Nx with 50+ TypeScript packages spending 2 minutes on type checking get that down to ~15 seconds. That is not a marginal improvement — it changes which workflows are practical.

The Migration Checklist

Before upgrading to TypeScript 6.0:

# 1. Audit implicit defaults in every tsconfig
grep -r '"target"' . --include="tsconfig*.json"
grep -r '"module"' . --include="tsconfig*.json"
 
# 2. Add explicit values for any that are missing
# (see tsconfig examples above)
 
# 3. Check for CJS consumers if you publish packages
cat package.json | grep '"type"'
 
# 4. Test with the RC before your team upgrades
npm install typescript@rc --save-dev
npx tsc --noEmit
 
# 5. Update eslint-typescript-parser and other TS-dependent tools
npm install @typescript-eslint/parser@latest @typescript-eslint/eslint-plugin@latest

After upgrading:

# Verify output target
npx tsc --showConfig | grep target
 
# Check for useDefineForClassFields regressions
# especially if you use decorators
npx tsc --noEmit --strict

FAQ

Will TypeScript 7.0 break my code?

No. The Go rewrite is a compiler implementation change, not a language change. Your TypeScript code compiles identically. The breaking changes are in 6.0 (new defaults), not 7.0.

When does TypeScript 7.0 ship?

No official date. The native preview is in Visual Studio 2026. Expect a public beta in 2026 with stable release likely 2027. The TS team has historically been conservative about release timelines.

Should I wait for 7.0 before updating?

No. TypeScript 6.0 is the current release track. The new defaults are worth addressing now. The performance gains from 7.0 are coming later.

Does the Go rewrite affect type compatibility or .d.ts output?

No. .d.ts files generated by the Go compiler will be byte-for-byte identical to those from the JS compiler. This was a hard requirement of the project.

What happens to TypeScript's self-hosting property?

It goes away. TypeScript will no longer compile itself. For the open-source contribution workflow, this means the compiler source will be in Go repositories, not the current TypeScript repo. The language specification and test suite remain.

Does this affect Deno or Bun?

Both runtimes have native TypeScript support via their own transpilers (which ignore types, similar to Babel). They will eventually adopt the Go-based LSP for IDE tooling. Their build-time story is largely unaffected.

My team is on TypeScript 4.x. Should we skip to 6.0?

Go to 5.x first, then 6.0. Each major version has its own set of strictness improvements and deprecations. Jumping two majors means debugging two sets of breakages simultaneously.

Conclusion

TypeScript 6.0 is a practical problem you need to solve this quarter. Audit your tsconfig defaults, lock them down explicitly, and test your builds before the upgrade happens underneath you via a lockfile update.

TypeScript 7.0 is the bigger story, but it is not your problem today. It is the culmination of a trend that started with esbuild in 2020 — native compilers running circles around their JavaScript equivalents. When it lands, large TypeScript projects will feel different. The edit-save-check loop will stop being something you work around.

Anders Hejlsberg built TypeScript to make JavaScript scale. Now he is rewriting the tool itself to keep pace with the codebases it enabled. That is a reasonable evolution.

Update your tsconfig. Watch the Go repo. Ship your product.