TypeScript 6.0 Released: The Last JavaScript-Based Version - New Features, Breaking Changes, and the Go Rewrite Coming in TypeScript 7

TypeScript has been written in TypeScript since its inception more than a decade ago. That self-hosted architecture delivered real benefits - the team could use their own tooling, the compiler served as a living test of the language - but it also created a performance ceiling that the project has been running into for years. Large codebases wait minutes for type checks. Monorepos choke on incremental builds. Editor responsiveness degrades as projects grow past a certain size.

On March 23, 2026, Microsoft released TypeScript 6.0 - and officially began the end of that era. This is the last major version of the TypeScript compiler written in JavaScript. Everything after it, starting with TypeScript 7.0 currently in preview under the codename Project Corsa, runs on a completely new compiler written in Go. Daniel Rosenwasser, principal program manager for TypeScript, called 6.0 a "bridge" release - and that framing is exactly right. The purpose of TypeScript 6.0 is not to introduce exciting new language features. It is to clean up a decade of technical debt, retire patterns that will not survive the transition to native code, and give developers a smooth migration runway before TypeScript 7 lands.

That makes 6.0 the release every TypeScript developer needs to understand right now, before the Go compiler arrives and removes all backward compatibility with the deprecated patterns.

What Is New in TypeScript 6.0

TypeScript 6.0 is less about additions and more about modernization. The new features that shipped are focused on aligning the language with where JavaScript and the web platform have actually moved since TypeScript 5.0.

Strict Mode Is Now On by Default

This is the single biggest behavioral change in TypeScript 6.0 for most existing projects. Previously, strict: true was opt-in. In TypeScript 6.0, strict mode is enabled by default for all projects. If your tsconfig.json never explicitly set strict, you have just inherited the full set of strict checks:

• strictNullChecks - variables are no longer implicitly nullable
• strictFunctionTypes - function parameter types are checked contravariantly
• strictBindCallApply - stricter types for bind, call, and apply
• strictPropertyInitialization - class properties must be initialized in the constructor
• noImplicitAny - implicit any is now an error
• noImplicitThis - this with an implicit any type is an error

Projects that were already running with strict: true will see no change. Projects that were not will likely see a wave of new type errors on upgrade. This is intentional. The TypeScript team is using 6.0 to close the gap between how most developers are already writing TypeScript and what the compiler enforces by default.

Improved Inference for Contextually Sensitive Functions

This is the most significant user-facing language improvement in 6.0. TypeScript has historically been over-cautious about inferring types in functions that lack explicit parameter types when those functions appear inside generic objects or callbacks. The new behavior is more precise, reducing the need for manual type annotations in common patterns like callbacks passed to generic utility functions. For most developers this means fewer explicit type arguments in everyday code rather than a change that requires migration.

Native Temporal Types

The ECMAScript Temporal proposal reached Stage 4 and is shipping natively in Firefox 139 and Chrome 144. TypeScript 6.0 adds Temporal to the standard lib, meaning you no longer need the @js-temporal/polyfill package for type definitions in environments that support it. Working with dates and times in TypeScript now has a properly typed, native API:

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

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

One important caveat: the TypeScript 6.0 Temporal types were written from scratch and are not compatible with older polyfill packages. If your project uses temporal-polyfill or @js-temporal/polyfill, those types are not interassignable with the new built-in declarations. You will need to remove the polyfill type dependency for environments that support Temporal natively.

New Types for Map and WeakMap Upsert Methods

The ECMAScript upsert proposal (Stage 4) adds two methods to Map and WeakMap that TypeScript 6.0 now types natively:

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

// Returns existing value, or inserts and returns defaultValue
const result = cache.getOrInsert("key", 0);

// Like getOrInsert but computes the default lazily
const computed = cache.getOrInsertComputed("key", (k) => expensiveCompute(k));

RegExp.escape Types

TypeScript 6.0 adds types for RegExp.escape(), the new static method that safely escapes special characters in strings for use in regular expression patterns. This eliminates the need for manual escape utilities or third-party packages for this common task.

Subpath Imports Starting with #/

TypeScript 6.0 now properly resolves Node.js subpath imports defined in package.json using the # prefix. This means import paths like import { util } from '#/utils' now work correctly without workarounds, aligning TypeScript with how the Node.js resolver actually handles these paths.

The stableTypeOrdering Flag

TypeScript assigns internal IDs to types in the order they are encountered, and those IDs affect how union types are ordered internally. TypeScript 7.0 changes this ordering. The new --stableTypeOrdering flag in 6.0 opts your project into the 7.0 ordering behavior now, so you can identify and fix any snapshot tests or type-ordering-dependent code before the Go compiler arrives.

ES2025 Target and lib Options

TypeScript 6.0 adds es2025 as a valid option for both target and lib, adding type definitions for the new built-in APIs that shipped in the ES2025 standard. While ES2025 introduced no new syntax features, several new built-in APIs are now properly typed.

The Breaking Changes: What Will Break When You Upgrade

TypeScript 6.0 carries the largest set of breaking changes since TypeScript 2.0. Microsoft is using this release to retire a decade of backward compatibility with patterns that no longer reflect how JavaScript is written or deployed in 2026. Here is what will affect real projects.

The ES5 target removal is the most historically significant of these changes. ES5 support was added when TypeScript was positioning itself as the language that could compile down to Internet Explorer-compatible JavaScript. That world no longer exists. Every relevant runtime environment in 2026 is evergreen, and the tooling to support true legacy targets lives in Babel and similar transpilers, not in the TypeScript compiler. Removing it is correct, but projects that have never revisited their tsconfig since 2018 may have surprises waiting.

The AMD and UMD module deprecations follow the same logic. These formats were created to solve module loading problems that predated native ES modules. Modern bundlers solve them better. The community-maintained TypeScript migration guide confirmed that when Microsoft tracked the top 800 npm repositories, zero raised concerns about outFile removal, meaning real-world usage had already fallen to effectively zero.

The Defaults That Changed in tsconfig

Beyond the explicit breaking changes, TypeScript 6.0 updates several default values in tsconfig.json to reflect modern JavaScript practices. These are not errors, they are new default behaviors that kick in if you do not explicitly set the values yourself.

• target now defaults to ES2023 instead of ES3. Projects that relied on the old ES3 default (which was almost none in 2026) need to set the target explicitly.
• module now defaults to ESNext for new projects, reflecting that ESM is now the standard output format.
• moduleResolution defaults to bundler when module is set to ESNext, aligning TypeScript's resolution logic with how modern bundlers actually resolve imports.
• types defaults to an empty array instead of pulling in all @types packages automatically. Microsoft reports this single change has improved build times by 20 to 50 percent in tested projects, because TypeScript no longer parses type definitions for packages that are never actually used.
• rootDir defaults to the directory containing tsconfig.json rather than being inferred from source file paths. This makes project structure more predictable and faster to parse.

TypeScript 7.0: Project Corsa and the Go Rewrite

Understanding why TypeScript 6.0 exists the way it does requires understanding what is coming next. TypeScript 7.0, codenamed Project Corsa, is a complete rewrite of the TypeScript compiler, type checker, and language service in Go. It is currently available in preview with nightly builds and a VS Code extension that developers can install and test today.

The performance numbers from the TypeScript team are striking:

These are not theoretical numbers. They come from running the actual Go-based tsgo compiler on real production codebases. For large teams, a 10x reduction in type-check time directly translates into faster CI/CD pipelines, faster pre-commit hooks, and real-time type checking that stays responsive in large monorepos where the current compiler starts to feel sluggish.

Why Go?

Microsoft's choice of Go over other languages is worth understanding. Anders Hejlsberg, lead architect of TypeScript, explained the reasoning clearly: the current JavaScript-based compiler has delivered enormous benefits but consistently hit performance and scalability walls tied to the Node.js runtime. Go's garbage collector and memory model map closely to how TypeScript's internal data structures work. More importantly, Go enables shared-memory multithreading - something the JavaScript runtime fundamentally cannot leverage due to its single-threaded execution model. True parallel type checking across large codebases requires the kind of concurrent programming model that Go provides natively.

The project was announced earlier in 2025 and has been progressing rapidly. As of the TypeScript 6.0 release, the Go compiler passes nearly all of TypeScript's 20,000-plus compiler test cases, with only 74 edge-case differences remaining in error detection. For daily development type-checking purposes, the TypeScript team says tsgo is already reliable enough for broad real-world testing.

What Changes in TypeScript 7.0 vs 6.0

TypeScript 7.0 will not be a feature release. It is an infrastructure release. The language semantics and type system remain the same. What changes is everything underneath:

• The tsc compiler binary becomes a native Go executable - no Node.js dependency required
• Build speed improves by roughly 10x for large codebases
• Memory usage drops by approximately 50%
• The existing Strada compiler API is replaced by the new Corsa API - tools that depend on the programmatic TypeScript API will need updates
• All features deprecated in TypeScript 6.0 are fully removed - no deprecation warnings, just errors
• ES5 target, AMD, UMD, SystemJS, and outFile are gone with no fallback

TypeScript 6.0 is explicitly designed so that a codebase that compiles cleanly on 6.0 with no deprecated patterns will compile cleanly on 7.0. The bridge metaphor is accurate. Get to 6.0 first, clean everything up, and the 7.0 upgrade should be nearly painless.

How to Migration from TypeScript 5.x to TypeScript 6.0

Here is a practical step-by-step migration path. The order matters - each step builds on the previous one.

Step 1: Install TypeScript 6.0 and Capture All Errors

Install TypeScript 6.0 and run tsc --noEmit to see the full list of new errors without changing any output. Do not fix anything yet - just collect the full picture of what breaks. This gives you a scoped list to work from.

npm install typescript@6 --save-dev
npx tsc --noEmit

Step 2: Handle Strict Mode Violations

If your project was not previously using strict: true, this will likely be your largest category of errors. You have two options: fix the violations to produce correctly typed code, or add "strict": false to your tsconfig temporarily to maintain the old behavior while you work through them incrementally. The first option is better long-term. The second is pragmatic for large codebases that cannot absorb all the changes at once.

Step 3: Update Your tsconfig Target

If you were targeting ES5, update to ES2015 or higher. For most projects in 2026, ES2022 or ESNext is the right choice. If your deployment environment genuinely requires ES5 output, that transpilation step belongs in Babel, not in the TypeScript compiler.

// tsconfig.json - before
{
  "compilerOptions": {
    "target": "ES5"
  }
}

// tsconfig.json - after
{
  "compilerOptions": {
    "target": "ES2022"
  }
}

Step 4: Migrate Away from AMD and UMD Modules

If your project uses module: "AMD", module: "UMD", or module: "System", switch to a modern bundler like Vite, esbuild, or Rollup for module bundling, and set module: "ESNext" or module: "CommonJS" in TypeScript depending on your target environment.

Step 5: Fix Import Patterns for esModuleInterop

With esModuleInterop now always enabled, the old namespace import pattern for CommonJS modules needs to change:

// Before (TypeScript 5.x with esModuleInterop: false)
import * as express from "express";
import * as fs from "fs";

// After (TypeScript 6.0 - esModuleInterop always enabled)
import express from "express";
import fs from "fs";

Step 6: Update Import Assertions Syntax

The old assert keyword for import attributes is deprecated. Update to the new with syntax:

// Before (deprecated in TypeScript 6.0)
import data from "./data.json" assert { type: "json" };

// After (TypeScript 6.0+)
import data from "./data.json" with { type: "json" };

Step 7: Set rootDir Explicitly if Needed

If your source files are nested below your tsconfig.json and you were relying on TypeScript to infer the common root directory, you now need to set it explicitly:

// tsconfig.json - add this if your src files are in a subdirectory
{
  "compilerOptions": {
    "rootDir": "./src"
  }
}

Step 8: Enable stableTypeOrdering and Fix Tests

Add "stableTypeOrdering": true to your tsconfig and run your full test suite. Any snapshot tests or type-ordering-dependent assertions that fail will also fail in TypeScript 7.0. Fix them now while you still have the JavaScript compiler as a fallback reference.

Step 9: Clean Up @types Imports

With types now defaulting to an empty array, TypeScript will no longer automatically include @types packages. Any global type definitions you depend on need to be explicitly listed in your tsconfig or imported directly in your code. This is the change most likely to give you "cannot find name 'X'" errors for globally available types after upgrading.

The TypeScript Ecosystem in 2026

TypeScript has become the de facto standard for large-scale JavaScript development. In August 2025, it surpassed Python as the most active language on GitHub by monthly contributors, reaching 2.6 million monthly contributors. Most new professional web projects now start with TypeScript rather than migrating to it. The question is no longer whether to use TypeScript - it is how to use it well.

TypeScript 6.0 landing is the right moment to pay that technical debt. Every pattern being deprecated in 6.0 is a pattern that was already creating friction in modern JavaScript development. ES5 targets, AMD modules, and implicit any types were all valid choices in 2013. They are maintenance burdens in 2026. The TypeScript team is not removing them arbitrarily - they are removing them because the cost of maintaining compatibility with a vanished ecosystem exceeds the benefit to the effectively zero projects that genuinely need them.

The Go rewrite is the bigger story, but it requires TypeScript 6.0 as a prerequisite. The performance improvements in TypeScript 7.0 are not cosmetic. A 10x reduction in compile time changes what is possible in CI/CD workflows, in pre-commit hooks, in editor integrations, and in how large monorepos are structured. Teams that have been working around TypeScript performance limitations with caching strategies, incremental builds, and project references will find many of those workarounds unnecessary once TypeScript 7.0 ships.

The timeline is clear. TypeScript 6.0 is available now. TypeScript 7.0 nightly previews are available now. The migration window is open. Teams that clean up to 6.0 baseline now will move to 7.0 with minimal friction. Teams that wait will absorb two releases of breaking changes at once under time pressure when 7.0 becomes the production default.