TypeScript 6.0 RC: New Features & TS7 Go Rewrite 2026

TypeScript 6.0 RC dropped in early March 2026, and it carries more historical weight than any release since TypeScript 2.0. It is the last version of the TypeScript compiler written in JavaScript. Everything after it — TypeScript 7 — runs on a brand-new Go implementation that Microsoft has been building under the codename Project Corsa.

This article covers what is actually new in 6.0 RC, which breaking changes will bite you, and what the Go rewrite means for your day-to-day TypeScript work.

TL;DR

TypeScript 6.0 RC makes strict true by default, removes ES5 output, deprecates AMD/UMD/SystemJS module formats, and adds stable Temporal types. It is a deliberate cleanup release designed to narrow the gap between the current JS compiler and the incoming Go compiler. TypeScript 7 rewrites the compiler in Go for roughly 10x faster builds and half the memory usage.

Key Takeaways

• strict: true is now the default — many projects will see new errors on upgrade
• ES5 output target is gone; use a transpiler like esbuild or SWC if you still need ES5
• AMD, UMD, and SystemJS module formats are deprecated
• isolatedDeclarations stabilizes in 6.0, enabling faster parallel declaration emit
• Temporal API types ship in the standard lib
• TypeScript 6.0 is the last JS-based release — TypeScript 7 is written in Go
• TS7 benchmarks: VS Code's 1.5M lines go from 89s → 8.7s; memory usage drops ~50%

Why TypeScript 6.0 Matters

TypeScript 6.0 is a bridge. The team's goal was not to ship flashy new type-system features but to bring the JavaScript-based compiler to a clean, modern baseline that can be replicated cleanly in Go. That means auditing every default, cutting dead-end module formats, and removing legacy targets that require special-casing in the new codebase.

If you are on TypeScript 5.x and your tsconfig.json was written conservatively (not opting in to strict mode, still targeting ES5, or using baseUrl without paths), TypeScript 6.0 will generate errors. That is intentional. The team wants everyone using defaults that reflect 2026's ecosystem before the Go compiler becomes the norm.

New Features in TypeScript 6.0 RC

strict Defaults to true

The biggest behavioural change: if your tsconfig.json does not set strict explicitly, it now defaults to true. This means strictNullChecks, strictFunctionTypes, strictBindCallApply, noImplicitAny, and the rest of the strict family are all on by default.

If you are upgrading an existing project, audit your tsconfig first:

// tsconfig.json — add this if you need time to fix strict errors incrementally
{
  "compilerOptions": {
    "strict": false
  }
}

Or use the new escape hatch flag "ignoreDeprecations": "6.0" to suppress deprecation warnings while you work through them.

Stable isolatedDeclarations

isolatedDeclarations was introduced experimentally in TypeScript 5.5. In 6.0, it is stable and recommended for library authors. When enabled, each file's declaration output can be computed without type-checking the whole program — enabling parallel .d.ts emit in build tools.

{
  "compilerOptions": {
    "isolatedDeclarations": true,
    "declaration": true
  }
}

The trade-off is stricter requirements on your API surface: you must explicitly annotate return types on exported functions. TypeScript will error on implicit return types when isolatedDeclarations is enabled.

// ❌ Breaks with isolatedDeclarations
export function createUser(name: string) {
  return { id: Math.random(), name };
}

// ✅ Required with isolatedDeclarations
export function createUser(name: string): { id: number; name: string } {
  return { id: Math.random(), name };
}

For build performance in monorepos or large libraries, this is a significant win. Tools like tsup already support isolatedDeclarations for faster .d.ts generation.

Temporal API Types

The ECMAScript Temporal proposal reached Stage 4 and is now shipping in Firefox 139+ and Chrome 144+. TypeScript 6.0 adds Temporal to the standard lib.

const now = Temporal.Now.plainDateTimeISO();
console.log(now.toString()); // "2026-03-18T14:23:00"

const meeting = Temporal.PlainDateTime.from("2026-04-01T09:00");
const diff = now.until(meeting);
console.log(`Meeting in ${diff.days} days`);

You no longer need the @js-temporal/polyfill package for type definitions in environments that support Temporal natively.

Map and WeakMap Upsert Methods

The ECMAScript "upsert" proposal adds getOrInsert() and getOrInsertComputed() to Map and WeakMap:

const cache = new Map<string, number>();

// Previously: if (!cache.has(key)) cache.set(key, expensive());
const value = cache.getOrInsert("key", 42);

// Or with a factory function:
const computed = cache.getOrInsertComputed("key", (k) => k.length);

#/ Subpath Imports

TypeScript 6.0 adds support for Node.js # subpath imports, letting you define internal package aliases in package.json:

{
  "imports": {
    "#utils": "./src/utils/index.js",
    "#types": "./src/types.js"
  }
}

// Resolves to ./src/utils/index.js
import { formatDate } from "#utils";

es2025 Target and Library

TypeScript 6.0 adds "target": "es2025" and "lib": ["es2025"], covering Promise.try, Float16Array, RegExp duplicate named groups, and the new iterator helper methods.

Breaking Changes from TypeScript 5.x

ES5 Output Removed

The "target": "es5" and "target": "es3" options are gone. The TypeScript team points to external transpilers for legacy output needs.

# If you need ES5 output, use esbuild after tsc:
esbuild dist/index.js --target=es5 --outfile=dist/index.es5.js

AMD, UMD, and SystemJS Module Formats Deprecated

"module": "AMD", "module": "UMD", and "module": "system" are deprecated. Modern bundlers like esbuild, Rollup, and Webpack handle multi-format output themselves. You can suppress the warning temporarily:

{
  "compilerOptions": {
    "ignoreDeprecations": "6.0",
    "module": "UMD"
  }
}

rootDir Defaults to Config Directory

Previously, rootDir defaulted to the longest common ancestor of all input files. Now it defaults to the directory containing your tsconfig.json. If you were relying on the old behaviour, you may need to set rootDir explicitly.

Empty Default types Array

"types": [] is now the default, meaning TypeScript no longer auto-includes @types/* packages from node_modules/@types unless you reference them in types or typeRoots. This prevents accidental global type pollution from installed @types packages.

Add explicit types for what you need:

{
  "compilerOptions": {
    "types": ["node", "jest"]
  }
}

baseUrl and Legacy Resolution Modes Deprecated

baseUrl without paths is deprecated. "moduleResolution": "node" is deprecated in favour of "node16", "nodenext", or "bundler".

--stableTypeOrdering Flag

TypeScript 7's Go compiler produces type union and intersection ordering that differs from the JS compiler. The new --stableTypeOrdering flag makes the JS compiler match the Go ordering, useful for comparing outputs during migration.

Migration Guide: 5.x → 6.0

Step 1: Upgrade TypeScript

npm install typescript@6 --save-dev
# or
pnpm add -D typescript@6

Step 2: Run tsc and collect errors

npx tsc --noEmit 2>&1 | tee ts6-errors.txt

Step 3: Address strict mode errors

The most common errors are implicit any and possible null/undefined:

// ❌ TypeScript 6.0 default: error TS7006
function process(data) { ... }

// ✅ Fix: add type annotation
function process(data: unknown) { ... }

Step 4: Fix rootDir and types

Add explicit rootDir if tsc complains about files outside the root:

{
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist"
  }
}

Step 5: Handle deprecation warnings

Either fix them immediately or gate with "ignoreDeprecations": "6.0". The TS team recommends fixing before TypeScript 7 ships since the Go compiler will not support the deprecated options at all.

TypeScript 7: The Go Rewrite

What is Project Corsa?

Microsoft announced in March 2025 that they were porting the TypeScript compiler to Go. The project is codenamed Corsa. The resulting compiler — shipping as TypeScript 7 — is a complete rewrite of the type checker, language service, and emit pipeline in Go, compiled to a native binary.

TypeScript 6.0 is explicitly positioned as the migration bridge: get your codebase to the 6.0 baseline, and the jump to 7.0 will be smooth.

Performance Numbers

The numbers are striking. VS Code has about 1.5 million lines of TypeScript. The current JS-based tsc compiles it in 89 seconds. The Go-based tsgo does the same job in 8.74 seconds — a 10.2x speedup. The Sentry codebase drops from 133 seconds to 16 seconds.

Memory usage is roughly half of the current implementation, and the team expects further improvements as they optimise the Go allocator patterns.

Project	tsc (JS)	tsgo (Go)	Speedup
VS Code	89s	8.7s	10.2x
Sentry	133s	16s	8.3x
TypeScript itself	~60s	~6s	~10x

Why Go and Not Rust?

The team's stated reasons: Go's garbage collector and memory model map more closely to TypeScript's existing data structures. The compiler was designed around mutable shared state; Rust's ownership model would require fundamental architectural changes. Go lets the team do a relatively faithful port while still achieving native speed.

What Changes for Developers

The tsgo CLI is a drop-in replacement for tsc. You run tsgo --noEmit or tsgo --project tsconfig.json the same way. Language service features — hover types, go-to-definition, diagnostics — work identically in editors.

The Go compiler is already stable enough for daily use in editors and command-line type checking as of the December 2025 update. Full emit (generating .js and .d.ts files) is still in progress.

Breaking Changes in TypeScript 7

• Deprecated options from 6.0 (AMD, UMD, ES5 target, baseUrl-only) will not be supported at all
• Type union/intersection ordering may differ — use --stableTypeOrdering in 6.0 to preview and fix
• Some edge-case type inference behaviour will change as the port matures

Timeline

• TypeScript 6.0 Beta: February 2026
• TypeScript 6.0 RC: March 2026
• TypeScript 6.0 Stable: Expected April/May 2026
• TypeScript 7 (Go-based) GA: Estimated late 2026 or early 2027

The native toolset is currently stable for type checking and editor use. Emit support is the main remaining work before 7.0 can reach stable.

Impact on the Ecosystem

Build Tools

Tools like tsup use esbuild for transpilation and tsc only for declaration files. Once tsgo supports full emit, declaration generation will be drastically faster. Libraries that currently take 10 seconds to build .d.ts files will take under 1 second.

The tsgo vs tsc comparison published earlier this month walks through the benchmark methodology in detail.

CI/CD

Type-checking in CI is one of the biggest beneficiaries. A large monorepo that currently blocks PRs for 2–3 minutes of tsc checks will drop to under 20 seconds. This removes a significant friction point from pull request workflows.

Editor Performance

The TypeScript language service powers type-checking in VS Code, WebStorm, Neovim, and every other major editor. The Go-based language service is already available as an opt-in in VS Code Insiders. The improvement in large files and complex generics is noticeable.

Preparing Your Team for TypeScript 7

The Go rewrite will be the most disruptive TypeScript upgrade most teams have ever experienced — not because the language changes dramatically, but because the tooling pipeline changes fundamentally. Here is how to prepare now while still on 6.0.

Audit your tsconfig options. Run tsc --showConfig and look for anything that is deprecated in 6.0. Every deprecated option is one that the Go compiler will not support. The transition from 6.0 to 7.0 will be much smoother if you are not carrying deprecated config debt.

Test with --stableTypeOrdering. Add this flag to your CI type-check command now. It aligns the JS compiler's type output ordering with the Go compiler, letting you discover any order-dependent tests or snapshot tests before 7.0 ships.

Watch the tsgo previews. The Go compiler is already available as @typescript/tsgo. Running it alongside tsc on your codebase will surface any behaviour differences early.

Prepare for faster CI. When your CI type-check step goes from 90 seconds to 9 seconds, you will want your CI yaml to take advantage of that. It is worth documenting current benchmark numbers now so you can measure the actual improvement when you migrate.

The TypeScript team has been explicit: TypeScript 6.0 is the on-ramp. Getting to 6.0 with no deprecation warnings and strict: true is the right move before 7.0 is generally available.

Methodology

Research for this article draws on the official TypeScript 6.0 RC announcement on the TypeScript blog, the TypeScript 7 progress updates from December 2025, the community-maintained TypeScript 5.x to 6.0 migration guide on GitHub, and performance benchmarks published by the TypeScript team in March 2025 and January 2026.