TypeScript 7 Go Compiler Hits RC and Runs 10x Faster

TypeScript's compiler is now written in Go, and it is roughly ten times faster. Microsoft shipped the TypeScript 7.0 Release Candidate on June 18, 2026, the first mainline build of Project Corsa, a full port of the compiler from its self-hosted TypeScript codebase to Go. The type system is unchanged, so your code still checks the same way, but the VS Code codebase now type-checks in about 7.5 seconds instead of 78, and the native binary ships back under the plain tsc command you already use.

• TypeScript 7.0 is a port, not a rewrite: the compiler was transplanted file-by-file from TypeScript to Go under the codename Project Corsa, preserving type-checking semantics.
• Microsoft's benchmarks show roughly 10x faster builds: VS Code (~1.5M lines) drops from ~78s to ~7.5s, Sentry from 133s to 16s, and editor startup from 9.6s to 1.2s with memory roughly halved.
• The RC folds the native binary back into the regular tsc command; the temporary tsgo name from the preview phase is gone.
• The catch: the programmatic API stabilizes in 7.1, so typescript-eslint, ts-morph and custom transformers should wait before fully switching.

What changed in TypeScript 7?

The compiler's implementation language. For its entire life, TypeScript's compiler was written in TypeScript itself, bootstrapped and compiled to JavaScript that ran on Node. Project Corsa took that codebase and ported it, file by file, to Go. Crucially, it is a port and not a rewrite: the team deliberately transplanted the existing structure rather than redesigning algorithms, so type-checking behavior stays identical. Of roughly 20,000 compiler test cases, about 6,000 produce at least one error in TypeScript 6.0, and in all but 74 of those, TypeScript 7.0 produces at least one error too. The promise is that anything compiling cleanly on 6.0 compiles identically on 7.0. What you gain is speed, and a lot of it, from native machine code plus shared-memory parallelism the JavaScript version could never touch.

RelatedPostgreSQL 19 Beta Makes Async I/O Actually Scale

Why Go instead of Rust?

Because the goal was a faithful port, and Go's model resembles the existing codebase closely enough to make that feasible. TypeScript dev lead Ryan Cavanaugh addressed the obvious question directly, noting that Rust "succeeds wildly at its design goals, but 'is straightforward to port to Rust from this particular JavaScript codebase' is very rationally not one of its design goals." In other words, Rust's ownership model would have forced a redesign, and a redesign risks subtly changing type-checking behavior across millions of existing codebases. Go's garbage collection and structural similarity let the team move the code without reinventing it, which is the entire reason semantics could be preserved. The compiler now parallelizes parsing, type-checking and emitting, exposed through new flags: --checkers for type-checker workers, --builders for parallel project builds, and --singleThreaded to force the old behavior.

The packaging detail matters more than it sounds. During the beta, the native compiler lived in the @typescript/native-preview package and ran as tsgo, so you could compare it side by side against tsc. With the RC, Microsoft folded it back into the regular TypeScript package: you install it and run tsc exactly as before. For a side-by-side migration you can still install TypeScript 6 alongside as a tsc6 binary. The name change signals confidence that this is the compiler now, not an experiment.

Who should switch, and when?

Editor users can switch today with almost no risk. The TypeScript Native Preview extension for VS Code has been battle-tested for months, and for large monorepos the difference between a 10-second and a 1-second editor startup is the difference between flow and frustration. Command-line builds and CI are the next easy win, since a 10x faster type-check reshapes how often you can afford to run it. The one group that should wait is tooling authors: typescript-eslint, ts-morph and custom transformers depend on the programmatic API, which does not stabilize until 7.1. Microsoft has been explicit that full ecosystem adoption is gated on that 7.1 API work, so if your build leans on custom AST transforms, hold until it lands.

RelatedAstral's ty Brings Rust-Speed Type Checking to Python

1. May 2025Native Previews (tsgo) released. First Go-based compiler preview aiming at TypeScript 7.
2. Apr 2026TypeScript 7.0 Beta. Built on the completely new Go foundation.
3. Jun 18, 2026Release Candidate. Go compiler moves into the mainline tsc command.
4. ~1 month outGeneral availability. Team estimate; published under the standard typescript tag.
5. 7.1Programmatic API stabilizes. Unblocks typescript-eslint, ts-morph and transformers.

Our take

This is the most consequential TypeScript release in years, and the smart move was the boring one. Microsoft could have chased Rust and the memory-safety headlines, and instead it optimized for the thing that actually matters at this scale: a faithful port that does not change how a million codebases type-check while making every one of them dramatically faster. Ten seconds off a VS Code type-check is not a demo stat, it is a daily quality-of-life change for anyone working in a large codebase, and folding it back under tsc means most developers upgrade without learning anything new. The honest caveats are the API gap until 7.1 and the fact that the benchmarks are vendor-run, so temper the exact multiplier. But the direction is unambiguous: the era of the slow TypeScript compiler is ending, and it took a Go rewrite that refused to be a rewrite to do it.

Original analysis by GenZTech. Benchmarks are Microsoft-reported; figures current as of July 2026. Source: devblogs.microsoft.com