Quick take: TypeScript 6 is the last JavaScript-based release, and it exists to smooth your path to TypeScript 7 (Project Corsa). Every compiler option that becomes a hard error in 7 shows up as a plain warning in 6 first. Upgrade to 6, clear the warnings, then bump to 7. That's the whole trick.
So what actually separates TypeScript 6 from TypeScript 7? The type system, nothing at all. Generics, conditional types, mapped types, strict-mode inference, all identical. The real split is the compiler underneath and how each version treats old settings. TS 6 runs on the same JavaScript engine that has shipped since 2012. TS 7 runs on a native Go rewrite that Microsoft clocks at 8x to 12x faster full builds. And the options TS 7 deletes outright? TS 6 keeps them alive but flags each one as a warning. That gap is the entire point of the release. If you want the full Go-rewrite backstory, I keep it in the Project Corsa overview; this piece is about the 6-to-7 seam specifically.
Why does TypeScript 6 even exist?
TypeScript 6 is a bridge, not a destination. Microsoft split the upgrade into two hops on purpose. Version 6 is the final release built on the original JavaScript codebase, nicknamed Strada. It ships the same speed you're used to, the same type-checker, the same emit. What it adds is a wall of deprecation warnings. Anything TS 7 removes, ES5 output, AMD and UMD and SystemJS modules, the classic and node10 resolution modes, still works in 6, but the compiler nags you about each one on every run. Think of 6 as a linter that only reports the changes 7 will force on you. You get to fix them on your own schedule, with green builds the whole time.
TypeScript 6 vs 7 at a glance
Here's the side by side. Same language, different engine, very different tolerance for legacy config.
| Dimension | TypeScript 6 | TypeScript 7 |
|---|---|---|
| Compiler language | JavaScript (the Strada codebase) | Go (Project Corsa) |
| Build speed | Same as TS 5.x | 8x to 12x faster full builds |
| Deprecated options | Emit a warning, build still passes | Hard error, build fails |
| Module output | ES5, AMD, UMD, SystemJS still emit | ES5/AMD/UMD/SystemJS all removed |
| Default strictness | strict is opt-in | strict is on by default |
| Editor experience | JS-based language service | Native Preview extension, near-instant |
The row that matters most is the third one. On 6 a deprecated option costs you a yellow warning. On 7 it costs you a red build failure. Almost everything else in a real migration follows from that single difference.
How does warning-first behavior de-risk the jump?
Picture two teams. One goes 5.4 straight to 7.0. The other parks on 6 for a sprint. The first team runs the native compiler cold and gets a screen of errors with terse, Go-generated messages, no context, no "this used to be allowed." The second team saw the same problems weeks earlier as readable warnings that named the exact flag and the exact file. Which afternoon would you rather have?
I lived the second path on a 40,000-line React app in June 2026. TS 6 warned that our moduleResolution: "node10" was on the way out and that two packages still leaned on it. Small fix, ten minutes. When I later flipped that same repo to 7, the identical config would have thrown TS2307: Cannot find module across a dozen imports at once, the kind of error that sends you chasing the wrong cause for an hour. Catching it as a warning on 6 turned a cryptic 7 failure into a boring one-line edit. That is the value of the bridge, and it kills most of the risks that make the jump feel scary. It's also why I think skipping 6 is a false economy.
What's the deprecation triage workflow?
Three moves. Nothing clever.
First, install 6 and print your effective config:
npm install -D typescript@6
npx tsc --showConfigtsc --showConfig prints the fully resolved tsconfig, including inherited and default values you never wrote by hand. Read it for the options 7 kills.
Second, run a no-emit check and take every warning seriously:
npx tsc --noEmitFix them in place. Swap target: "es5" for es2021 or newer. Move module off AMD or UMD onto esnext or nodenext. Replace moduleResolution: "node10" with "bundler" or "nodenext". Turn strict on now, because 7 defaults it on regardless.
Third, once tsc --noEmit is silent, bump the version and re-check:
{
"devDependencies": {
"typescript": "^7.0.0"
}
}A repo that was warning-clean on 6 usually comes up green on 7 the very first run. Isn't that a nicer Friday than debugging a wall of Go errors you've never seen before?
Should you skip 6 and jump straight to 7?
Honestly? Only if your tsconfig is already spotless and you like living dangerously. For a greenfield project with strict on and modern module settings, go straight to 7, there's nothing for 6 to warn about. For anything with history, the two-hop route is faster in wall-clock terms even with the extra step, because every problem shows up pre-labeled instead of raw. The exact command sequence, tool by tool, lives in the full migration guide. Do the boring thing here. Stop at 6, clear the warnings, then move.
Related
- TypeScript strict mode guide - turn strict on during the 6 step, since TypeScript 7 defaults it on anyway