TypeScript 6.0 Is Here, And Yes, It's Judging Your Code More Than Ever

Published: March 2026 | Read time: ~16 minutes

TypeScript 6.0 shipped on March 23, 2026.

And if you haven't looked at the release notes yet — you probably should. This isn't a quiet "a few new features and some bug fixes" release. TypeScript 6.0 changed 9 default settings at once, removed some options entirely, and is going to break things for a lot of teams who upgrade without looking first.

But here's the part that makes this release genuinely exciting: it's the last version of TypeScript written in TypeScript. Microsoft has been quietly rebuilding the entire compiler in Go. They're calling it Project Corsa, and the benchmarks are legitimately wild — VS Code's 1.5 million lines of code went from a 77-second type-check down to 7.5 seconds.

That's not a small improvement. That's a different category of tool.

Let's break down everything you need to know — the new features, the breaking changes, how to upgrade without pain, and what this Go rewrite actually means for you.

The New Stuff — What TypeScript 6.0 Actually Adds

Let's get the good news out of the way first.

TypeScript Got Better at Guessing Types

TypeScript has always been pretty smart about inferring types automatically. In 6.0, it got a bit smarter.

Specifically: functions that don't have an explicit this parameter are no longer treated as "context-sensitive" during generic inference. In plain English, this means TypeScript can figure out the correct type in more situations without you having to manually annotate it.

typescript

// TypeScript 5.x sometimes couldn't figure this out
function process<T>(value: T, transform: (x: T) => T): T {
  return transform(value);
}

// In 6.0, TypeScript correctly infers T = number here
const result = process(42, (x) => x * 2);

Most people won't notice this one consciously. You'll just see fewer places where you're fighting the compiler.

Cleaner Module Imports with #/

If you've ever used Node.js subpath imports in package.json, TypeScript now fully understands the #/ shorthand.

json

// package.json
{
  "imports": {
    "#/*": "./src/*"
  }
}

typescript

// Instead of this
import { formatDate } from '../../utils/formatDate';

// You can now do this
import { formatDate } from '#/utils/formatDate';

Clean, short, and TypeScript resolves it correctly — including go-to-definition and all the IDE stuff.

Strict Mode Is Now On by Default

This is the big one that affects existing projects the most.

Before TypeScript 6.0, if you created a tsconfig.json without setting strict, TypeScript assumed you wanted the relaxed defaults. In 6.0, it assumes strict: true.

That means 8 checks are now on by default:

• strictNullChecks — null and undefined are treated as their own types
• noImplicitAny — TypeScript won't silently let things become any
• strictFunctionTypes — function parameters are checked more carefully
• strictPropertyInitialization — class properties must be set in the constructor
• strictBindCallApply — bind, call, and apply are properly type-checked
• noImplicitThis — this can't implicitly be any
• alwaysStrict — "use strict" gets added to every output file
• useUnknownInCatchVariables — caught errors are unknown, not any

If your project didn't have strict: true before, you're going to see a wall of red when you upgrade. More on how to handle that in the breaking changes section below.

Modern JavaScript APIs Are Now Included by Default

TypeScript 6.0 defaults to targeting ES2025, which means all the newer JavaScript built-ins are included in the type definitions out of the box. No extra lib configuration needed.

A few highlights:

typescript

// Set operations — no library needed
const a = new Set([1, 2, 3]);
const b = new Set([2, 3, 4]);

a.intersection(b); // Set { 2, 3 }
a.union(b);        // Set { 1, 2, 3, 4 }
a.difference(b);   // Set { 1 }

// Promise.try — wraps sync code in a promise and catches errors
const result = await Promise.try(() => JSON.parse(someString));

Iterator helpers are also included — map, filter, take, drop — all usable on native iterators without pulling in a library.

The Temporal API — A Proper Date Object, Finally

If you've ever tried to do anything slightly complicated with JavaScript's Date object, you know it's a mess. Timezones are unreliable. Mutations happen in weird places. It's a bad API that's been with us since 1995.

Temporal fixes all of it. It's immutable, it handles timezones correctly by design, and it works at nanosecond precision.

TypeScript 6.0 adds the type definitions for it. To use them:

json

{
  "compilerOptions": {
    "lib": ["esnext", "esnext.temporal", "dom"]
  }
}

typescript

const today = Temporal.Now.plainDateISO();
const eventDate = Temporal.PlainDate.from('2026-12-25');
const daysUntil = today.until(eventDate).days;

console.log(`${daysUntil} days to go`);

Browser support: Firefox added it in May 2025, Chrome in January 2026, Safari is still pending. If you need to support Safari today, install @js-temporal/polyfill.

Two New Map Methods That Clean Up Ugly Code

You've probably written this pattern a hundred times:

typescript

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

// Check, then set, then get — three lines every time
if (!counts.has(key)) {
  counts.set(key, 0);
}
const count = counts.get(key)!;

Now you can do this instead:

typescript

const count = counts.getOrInsert(key, 0);

Or with a computed default (useful when creating the default is expensive):

typescript

const data = cache.getOrInsertComputed(userId, () => loadFromDatabase(userId));

Small change. Makes code much more readable.

RegExp.escape() — Protect Yourself from Regex Injection

If you've ever taken user input and stuck it inside a new RegExp() call, you've had a potential security bug. Special characters in the input could break or hijack your regex.

RegExp.escape() fixes this properly:

typescript

const userInput = "price: $10.00 (final)";
const safe = RegExp.escape(userInput);
const pattern = new RegExp(safe); // dots and dollar signs are properly escaped

TypeScript 6.0 adds the type definition. Simple, useful, should have existed years ago.

A Couple of Smaller Quality-of-Life Updates

dom.iterable is now included automatically. If you have "lib": ["dom", "dom.iterable", "esnext"] in your tsconfig, you can drop dom.iterable — it's bundled into dom now.

isolatedDeclarations is now stable. This feature lets build tools generate .d.ts declaration files in parallel, without running the full TypeScript compiler. If you maintain a library or work in a large monorepo, enabling this can meaningfully speed up your builds.

json

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

The Breaking Changes — Read This Before You Upgrade

Alright. Here's the part you actually need to sit down and read carefully.

TypeScript 6.0 changed 9 default compiler settings. Most of these are changes in the right direction — the new defaults are what most teams should have been using anyway. But if your tsconfig.json relied on the old defaults without explicitly setting them, things are going to break.

Here's the full picture:

Let's go through the ones that are actually going to bite you.

strict: true — Expect a Wall of Errors

If you don't have strict set in your tsconfig, upgrading to TypeScript 6.0 will surface a lot of errors that were previously hidden. That's the point — these are real potential bugs in your code.

The two most common ones you'll see:

typescript

// Error: Object is possibly 'null'
function getLength(items: string[] | null) {
  return items.length; // TS 5.x let this slide. TS 6.0 won't.
}

// Fix:
function getLength(items: string[] | null) {
  return items?.length ?? 0;
}

typescript

// Error: Parameter 'item' implicitly has an 'any' type
[1, 2, 3].forEach(function(item) { // TS 5.x let this slide too
  console.log(item);
});

// Fix: use an arrow function (TypeScript infers the type from context)
[1, 2, 3].forEach((item) => console.log(item));

Not ready to fix all of these right now? You can opt out explicitly:

json

{
  "compilerOptions": {
    "strict": false
  }
}

But put it on your list. Don't just leave it there forever.

types: [] — The Sneaky One That Breaks Node.js

This is the change that catches people off guard the most.

In TypeScript 5.x, the compiler would automatically pick up every @types package in your node_modules. You didn't have to do anything — install @types/node and it just worked.

In 6.0, types defaults to an empty array. TypeScript no longer automatically discovers your @types packages.

The first sign you'll see: errors like Cannot find name 'process' or Cannot find name 'Buffer' even though you have @types/node installed.

Fix it in your tsconfig:

json

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

Using Jest? Vitest? Add those too:

json

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

The upside: TypeScript only loads the type definitions you actually use. This can make type-checking 20-50% faster in projects that had a lot of unused @types packages sitting around.

rootDir Changed — Your Output Folder Structure Might Look Wrong

This one is subtle but annoying.

Before TypeScript 6.0, when you didn't set rootDir, TypeScript would infer it as the common source root of all your files. So if all your code was in ./src, it would infer rootDir: ./src and output files cleanly into outDir.

In 6.0, TypeScript defaults rootDir to the folder containing your tsconfig.json. That means if your tsconfig.json is at the project root and your code is in ./src, you'll get this:

dist/
  src/       ← Wait, why is there a src folder here?
    index.js
    utils.js

Fix: be explicit about rootDir:

json

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

ESM Is the New Default — Node.js Projects, Pay Attention

Your project now outputs ESM by default. For browser projects using a bundler, this is probably fine — the bundler handles it.

For Node.js projects that use require() and CommonJS, you need to be explicit:

json

// Keep CommonJS for now
{
  "compilerOptions": {
    "module": "commonjs",
    "moduleResolution": "node10"
  }
}

Or go full ESM (recommended for new projects):

json

{
  "compilerOptions": {
    "module": "nodenext",
    "moduleResolution": "nodenext"
  }
}

The esModuleInterop: true default also means your import style can change. The old import * as fs from 'fs' still works, but now you can use the cleaner default import:

typescript

// Both work in 6.0, but this is now the standard style:
import fs from 'fs';

Three More Things That Changed (Quick Version)

ES5 output is deprecated. If you have "target": "es5" in your tsconfig, you'll see a deprecation warning. Modern browsers, Node.js, Deno, and Bun all support ES2020+ natively. There's barely a reason to compile to ES5 anymore. If you still need it, add "ignoreDeprecations": "6.0" — but know that this option stops working in TypeScript 7.0.

AMD, UMD, and SystemJS module formats are gone. These are old module systems that almost nobody uses anymore. If you are using them, you'll need to switch to ESM output and let your bundler handle the format.

Import assertions are now import attributes. The syntax assert { type: 'json' } is now with { type: 'json' }. One word change, but it affects any JSON import statements in your code:

typescript

// Old
import config from './config.json' assert { type: 'json' };

// New
import config from './config.json' with { type: 'json' };

How to Actually Upgrade — Without Spending a Week on It

Here's the good news: most of this can be automated.

Step 1: Run This First

bash

npx @andrewbranch/ts5to6

This migration tool was built specifically for the TypeScript 5 → 6 upgrade. It handles:

• Moving baseUrl to paths
• Setting explicit rootDir
• Updating assert {} to with {} in import statements
• Fixing extends chains in multi-tsconfig projects

Run it before touching anything manually.

Step 2: Install TypeScript 6.0

bash

npm install -D typescript@latest

Then run a type-check to see what's left:

bash

npx tsc --noEmit

Step 3: Fix the Most Important Things First

Do these before anything else — they affect almost every project:

1. Add "types" to your tsconfig — ["node"] at minimum, plus any test framework types you need
2. Set an explicit "rootDir" — usually "./src"
3. Decide on strict — fix the errors if you can, or explicitly set "strict": false with a plan to come back to it

Step 4: Clean Up the Rest

• Remove baseUrl — the migration tool should have handled this
• Update moduleResolution if you're building for Node.js
• Remove deprecated options: downlevelIteration, outFile, AMD/UMD module settings

How Long Will This Take?

A modern project targeting ES2020+ should be fully upgraded in under an hour. An older project with ES5 targets, AMD modules, or a messy baseUrl setup will take longer — budget half a day.

The ignoreDeprecations: "6.0" option is there if you need to buy time. But it's not a permanent solution — it stops working when TypeScript 7.0 ships.

What About Your Other Tools?

ESLint / typescript-eslint — Check the typescript-eslint docs for the current compatibility status before upgrading. TypeScript major versions sometimes require a parser update.

Bundlers (Vite, esbuild, webpack) — Mostly fine. These tools strip TypeScript types at build time rather than using the TypeScript compiler to compile. Vite users may actually find fewer edge cases after upgrading, since the new bundler moduleResolution default aligns with how Vite handles modules.

Next.js, Angular, React — Standard process: upgrade in a dev branch, run your build and tests, fix errors, ship to production. Next.js usually moves fast on TypeScript support. Check Angular's compatibility matrix before upgrading.

The Go Rewrite — What Microsoft Is Actually Building

Okay, now for the actually exciting part.

What Is Project Corsa?

Microsoft is porting the TypeScript compiler from JavaScript to Go. The project is called Project Corsa, the binary is called tsgo, and it lives at microsoft/typescript-go on GitHub.

They've been working on this for a while. And the early results are not subtle.

The Performance Numbers

The editor also loads projects 8x faster. Memory usage is cut in half.

If your TypeScript builds are slow right now, this is a genuinely big deal.

Why Go? (And Not Rust?)

This is the question everyone's been asking. The JS tooling ecosystem in 2026 is going heavily Rust — Biome, Oxlint, Rolldown, SWC. TypeScript picking Go makes it the outlier.

Here's the honest reason: a port is very different from a rewrite.

TypeScript's compiler wasn't designed to be ported to Rust. It has lots of shared mutable state, complex recursive type inference, and 12+ years of evolved code. Mapping that to Rust's ownership model would have required rewriting huge chunks of the logic from scratch — which means years of work and a real risk that TypeScript 7.0 would behave differently from TypeScript 6.x in subtle ways.

Go is simpler. The TypeScript codebase's structure maps reasonably well to Go's patterns. That means the team can translate the existing code rather than reinvent it. And translating means you can verify correctness by running the exact same 20,000 tests against both compilers.

Those 20,000 tests? Only 74 discrepancies. That's remarkable for a project this size.

What "Port" vs "Rewrite" Means for You

The Go compiler isn't a new TypeScript — it's the same TypeScript, just running much faster. If your code compiles with 6.x, it will compile the same way with 7.0.

This is intentional. The team could have used this as an opportunity to change how TypeScript works. They chose not to. Speed first, then explore improvements.

A New Thing: Real Parallel Compilation

The current JavaScript compiler processes your project one thing at a time. It's fundamentally single-threaded.

The Go version can process different parts of your project simultaneously — different packages in a monorepo running on different CPU cores at the same time.

For large projects, this might actually be bigger than the raw language-level speedup. The single-threaded bottleneck was always the architectural limit.

The Editor Is Changing Too

TypeScript currently uses a custom protocol called TSServer to talk to editors. TypeScript 7.0 switches to the standard Language Server Protocol (LSP).

For VS Code users, this is invisible. For Neovim, Helix, Zed, JetBrains, Emacs users — it means the editor doesn't need special TypeScript-specific integration. Standard LSP tooling just works.

Can You Try It Right Now?

Yes.

Option 1: Install the VS Code extension. Search for "TypeScript (Go)" in the VS Code marketplace. It updates with new tsgo builds daily. You can enable it per workspace and compare performance against the regular compiler on your own project.

Option 2: Use the command line.

bash

git clone https://github.com/microsoft/typescript-go
cd typescript-go
go build ./cmd/tsgo
./tsgo --noEmit

What works today: type-checking, completions, go-to-definition, rename, quick fixes, project references, --build mode.

What's still in progress: emit targets below ES2021, decorators, compiler plugin API.

When Is TypeScript 7.0 Coming Out?

Here's the current timeline:

TypeScript 6.x will get bug fixes but no new features. The team's energy is on the Go compiler now.

You Really Shouldn't Skip 6.0

Here's why this matters: every deprecation warning you suppress in 6.0 with "ignoreDeprecations": "6.0" becomes a hard error in TypeScript 7.0. That option simply stops working.

If you skip the 6.0 upgrade and go straight to 7.0 when it ships, you'll face all the same migration work at once, without the automated tools, under a tighter deadline.

Upgrade now. Do the work once, do it cleanly.

A Note for Plugin Authors

The internal TypeScript API that compiler plugins use — sometimes called the Strada API — is not being carried over to the Go compiler. A new Corsa API is being built.

If you maintain TypeScript plugins or build tools that use TypeScript's programmatic API, start watching the microsoft/typescript-go repository. The new API design is still in progress, and getting involved early is much better than scrambling when 7.0 ships.

The Bigger Picture

The End of TypeScript Compiling Itself

Since the early days, TypeScript has been written in TypeScript. The compiler compiles itself. It's a neat property that the team was proud of.

TypeScript 6.0 is the last version where that's true. Starting with 7.0, TypeScript will be built with Go tooling.

It's a pragmatic trade-off. The team weighed a 10x performance improvement against a philosophical property and made the call. For everyone who's watched large TypeScript builds chug along, it feels like the right call.

What This Tells Us About the TypeScript Team

There's something worth noting here: the TypeScript team is small. They don't have unlimited resources to spend years on a speculative rewrite in an unfamiliar language.

Choosing Go — a simple language with a one-year port timeline rather than a multi-year Rust rewrite — is the kind of decision a practical, focused team makes. They're not trying to win points for using the trendiest language. They're trying to make TypeScript 10x faster in the shortest responsible time.

That's a good sign for the long-term health of the project.

Your Questions, Answered

Is TypeScript 6.0 backward compatible with 5.x?

Mostly yes. The TypeScript language itself hasn't changed — valid 5.x code is still valid 6.0 code. What changed are the compiler defaults. If you have an explicit tsconfig.json that sets strict, module, target, and types, you probably won't see many issues.

Do I need to learn Go to use TypeScript 7.0?

No. You run tsc (or tsgo). You edit tsconfig.json. You get errors in your editor. It works exactly the same way — just faster.

Is TypeScript 7.0 ready to use now?

Not for production. The tsgo preview is available and actively developed, but it's not feature-complete yet. Expect a stable release in late 2026 or early 2027.

What happens to my compiler plugins in 7.0?

The current plugin API will not work in TypeScript 7.0. A new API is being built. If you depend on compiler plugins, track the microsoft/typescript-go repository and plan ahead.

Should I upgrade now or wait for 7.0?

Upgrade to 6.0 now. Waiting doesn't help — it just means a harder upgrade later when 7.0 ships. The migration tooling for 6.0 is good, and doing it in stages is always easier than doing it all at once.

Does TypeScript 6.0 still support CommonJS?

Yes. Set "module": "commonjs" explicitly in your tsconfig and everything works as before. ESM is just no longer the default.

What's the ts5to6 tool?

It's npx @andrewbranch/ts5to6 — a CLI that automates most of the mechanical parts of the 5 → 6 migration. Run it before doing anything manually.

Is strict mode now forced on?

No. strict: true is the new default, but "strict": false still works if you set it explicitly. It's not enforced, just encouraged.

Where This Leaves Us

TypeScript 6.0 is a cleanup release. It's the kind of release that doesn't get a lot of hype but matters a lot — it removes years of accumulated defaults that were out of step with how people actually build things now, and it sets up every codebase for a much better future.

And that future — TypeScript 7.0 with the Go compiler — is genuinely something to be excited about. Compile times that took over a minute dropping to under 10 seconds changes how you work. Suddenly your save-to-feedback loop in the editor feels different. CI runs finish before you've checked Slack.

The 10x number isn't marketing. The benchmarks are public. You can try it on your own project today.

So: upgrade to TypeScript 6.0 now. Use the migration tool. Fix the deprecations. And install the tsgo extension so you know exactly what you're getting when 7.0 ships.

What to Do Right Now

• Run npx @andrewbranch/ts5to6 in your project
• Run npm install -D typescript@latest
• Add "types": ["node"] to your tsconfig
• Set an explicit "rootDir": "./src"
• Fix strict mode errors — or set "strict": false with a note to revisit
• Install the "TypeScript (Go)" VS Code extension and feel the difference