TypeScript Goes Native: The Go-Powered 7.0 Compiler Lands in 2026
Microsoft is shipping TypeScript 7.0, a full rewrite of the compiler in Go, with 6.0 as a bridge release — matching the old typechecker on all but 74 of ~20,000 test cases.
TL;DR — Microsoft is releasing TypeScript 7.0 ("Project Corsa"), a native rewrite of the compiler in Go for big gains in speed and memory, with TypeScript 6.0 serving as a bridge release in 2026.
TypeScript has quietly become the language a huge chunk of the web is actually written in. It also has a not-so-quiet problem: on large codebases, the compiler and editor tooling can feel like wading through molasses. Microsoft's fix is the kind of swing teams rarely take on a project this load-bearing — a from-scratch rewrite of the compiler in a different language entirely.
That language is Go, the project is codenamed Corsa, and it ships as TypeScript 7.0. The whole thing is a bet that you can re-implement one of the most widely used dev tools on Earth without breaking the millions of projects that depend on it.
Two releases, one transition
Microsoft is splitting the move into two versions, and getting that distinction right matters if you maintain TypeScript code:
- TypeScript 6.0 — the last release built on the existing JavaScript/TypeScript codebase. It's a compatibility bridge.
- TypeScript 7.0 — the native build, rewritten in Go, targeting major wins in performance, memory usage and parallelism.
As InfoWorld reported, Microsoft principal product manager Daniel Rosenwasser framed the sequencing plainly: "You can think of TypeScript 6.0 as a 'bridge' release between the TypeScript 5.9 line and 7.0... 6.0 will deprecate features to align with 7.0."
In other words: 6.0 warns you about what's changing, 7.0 delivers the new engine.
The number that should reassure you
Rewriting a typechecker is terrifying precisely because correctness is the whole point — a compiler that's fast but subtly wrong is worse than a slow one. So the most important figure in the whole project isn't a speedup; it's a fidelity stat.
Per InfoWorld, across roughly 20,000 compiler test cases (about 6,000 of which produce errors), TypeScript 7.0 matches the behavior of TypeScript 5.9 in all but 74 cases. That's an enormous bar to clear for a clean-room reimplementation, and it's the kind of evidence that makes a migration credible rather than aspirational.
| Item | Detail |
|---|---|
| Codename | Project Corsa |
| New language | Go |
| Bridge release | TypeScript 6.0 |
| Native release | TypeScript 7.0 |
| Test fidelity | Matches 5.9 on all but 74 of ~20,000 cases |
Why Go, and why now
Microsoft's public materials are more cautious than the hype around the project; the InfoWorld write-up frames the goals in terms of "performance, memory usage, and parallelism" rather than a single marketing multiplier. Go buys the team easy concurrency and predictable memory behavior — both exactly what you want when typechecking a million-line monorepo, where the old single-threaded design hits a wall.
The strategic read is just as interesting. This is Microsoft choosing Google's language to rebuild Microsoft's language — a pragmatic, ego-free engineering call that says a lot about how mature the open-source toolchain has become. The work is happening in the open, on GitHub, where anyone can watch the new compiler get hammered against the old one's test suite.
What it means for developers
For day-to-day work, the promise is simple: faster cold starts in the editor, snappier type checking in CI, and headroom for codebases that currently strain the tooling. The migration friction concentrates in 6.0's deprecations — heed those warnings and 7.0 should be a drop-in upgrade for most projects. Ignore them, and you'll meet a few of those 74 edge cases personally.
FAQ
What is Project Corsa?
Project Corsa is Microsoft's codename for the native rewrite of the TypeScript compiler in Go, shipped as TypeScript 7.0. It aims to dramatically improve compile speed, memory use and parallelism over the current JavaScript-based implementation.
Do I need to change my code for TypeScript 7.0?
Most projects won't need major changes, but TypeScript 6.0 acts as a bridge release that deprecates features to align with 7.0. Following those deprecation warnings in 6.0 is the way to ensure a smooth move to the native compiler.
Is the new TypeScript compiler reliable?
Early evidence is strong: across roughly 20,000 compiler test cases, the Go-based TypeScript 7.0 matches the existing 5.9 typechecker in all but 74 cases, indicating very high behavioral fidelity.
Sources: InfoWorld, Microsoft/TypeScript on GitHub.
Image: Microsoft, Apache License 2.0, via Wikimedia Commons.
← Back to all posts