TypeScript 7.0 Rewrites Its Compiler in Go: 10x Speed, Same Types

Microsoft just did something that almost never happens in mature language infrastructure: they made it dramatically faster without changing what it does. TypeScript 7.0 Beta — codenamed Project Corsa — ports the entire compiler from TypeScript/JavaScript to Go, delivering approximately a 10x reduction in compile time with no changes to the type system or language semantics. The VS Code codebase, 1.5 million lines, went from 78 seconds to 7.5 seconds. That number lands differently when you have been watching your CI pipeline wait on type checking for every PR.

This is not TypeScript adding new syntax, deprecating features, or restructuring its module system. It is exclusively a performance rewrite. The type-checking logic is structurally identical to TypeScript 6.0, released in March 2026 as the last JavaScript-based compiler. If your code type-checks on 6.0, it type-checks on 7.0. The RC is expected within weeks of this writing.

To understand why this matters beyond benchmark numbers, consider what slow TypeScript compilation actually costs. At the IDE layer, type errors surface with perceptible latency, go-to-definition feels sluggish, and refactoring across large files produces noticeable hangs. In CI, type checking is often the longest-running step in a frontend build pipeline, adding 60 to 90 seconds to every PR check on large codebases. For teams with dozens of active PRs, this compounds into meaningful developer hours. The Go rewrite addresses this architecturally. JavaScript's single-threaded event loop is fundamentally at odds with the embarrassingly parallel nature of type checking across independent modules. Go's goroutines allow the new compiler — shipped as a CLI called tsgo and the npm package @typescript/native-preview — to parallelize type checking across the module graph in a way the JavaScript implementation structurally cannot. This is not a constant-factor improvement from better algorithms. It is a concurrency model change that unlocks parallelism the original runtime never supported.

The clean migration story is what makes this significant for engineering leaders rather than just interesting to compiler engineers. Microsoft made a deliberate decision to freeze the type system at 6.0 semantics before the rewrite, meaning TypeScript 7.0 is not 6.0 plus features plus a faster compiler. It is 6.0 semantics running on a Go engine. No breaking type-level changes to manage. Your existing tsconfig.json works. Your existing type definitions work. The migration path is straightforward: install the beta, run tsgo, see if anything breaks. For most codebases, nothing will.

The broader signal connects to a pattern across developer tooling over the past two years: performance-critical infrastructure is migrating to compiled, systems-language implementations. Rome/Biome rewrote JavaScript tooling in Rust. esbuild and Bun rewrote bundling and the runtime. ESLint's OXLint is Rust-based and runs 50 to 100 times faster. TypeScript joining this cohort is the most significant instance yet, because type checking is the single most performance-critical step in the average frontend CI pipeline. Faster type checking also supports secure coding practices directly — the faster your safety checks run, the more likely developers are to treat them as part of the workflow rather than an obstacle to route around.

For teams building at scale, the practical action is immediate: run npm install -D @typescript/native-preview and npx tsgo --version in a test branch today, and report any discrepancies between tsgo and tsc output. The TypeScript team is actively collecting them before RC finalization. Teams that validate now will have a smooth GA upgrade path. One supply chain note: the Go-based compiler introduces a new compiled binary in your toolchain. Treat it as you would any binary build dependency — verify checksums, pin versions in your lockfile, and pull only from the official npm and TypeScript GitHub releases channels. The 10x benchmark is verified against a 1.5 million line production codebase. The migration cost for most teams is effectively zero. This is the rare infrastructure upgrade worth acting on before the stable release.