From Strada to Corsa, In Production
On June 18, 2026, Microsoft shipped the release candidate for TypeScript 7.0, the first mainline version whose compiler is written in Go instead of TypeScript itself. The project began in 2025 under the internal codename Corsa, with the legacy JavaScript-based codebase retroactively dubbed Strada. The headline claim is blunt: the native port is often roughly 10x faster than TypeScript 6.0, turning type checks that once ran for minutes on large codebases into single-digit-second runs. Memory usage is roughly halved, and Microsoft reports failing language server commands down by more than 20x.
What makes the RC credible is that it is a port, not a rewrite of semantics. Microsoft has been careful to say the new compiler preserves identical type-checking behavior, so existing projects should see the same errors, only faster. That distinction matters enormously for adoption. A faster compiler that quietly changes which programs type-check would be a migration nightmare; a faster compiler that produces byte-for-byte the same diagnostics is a drop-in upgrade. The RC is on npm immediately, and Microsoft estimates general availability within roughly a month, though it is careful to frame that as an estimate rather than a fixed date.
The Numbers That Matter
The benchmarks circulating from the RC are specific enough to test. Visual Studio Code, at roughly 1.5 million lines, drops from 77.8 seconds to 7.5 seconds, a 10.4x improvement. TypeORM falls from 17.5 seconds to 1.3 seconds, about 13.5x. Playwright goes from 11.1 seconds to 1.1 seconds, and Sentry from 133 seconds to 16.25 seconds. Editor project load time, the lag before your IDE understands a project, drops from 9.6 seconds to 1.2 seconds. Across the board the pattern holds: the larger and more complex the codebase, the more dramatic the win.
That scaling characteristic is the real product. The improvement to watch mode and the language server is arguably more important than the cold-build number, because it changes the feel of editing. When the type checker keeps up with keystrokes on a million-line monorepo, autocomplete, go-to-definition, and inline errors stop lagging behind the developer. We have all worked in repositories where the IDE's understanding trailed reality by seconds, and that gap is where bugs slip in. Cutting language server failures by more than 20x is the kind of reliability change that does not photograph well but reshapes the daily experience.
Why Go, and Why Not Rust
The choice of Go over Rust raised eyebrows in a moment when Rust dominates the conversation around fast developer tooling. Microsoft's reasoning is technical and worth understanding. TypeScript's abstract syntax tree and type structures are full of cyclic references, the kind of mutually pointing graphs that a garbage-collected, shared-memory model handles naturally. Go provides exactly that, which let the team complete the port in roughly a year while preserving the original algorithms. A Rust port would have meant fighting the borrow checker over those cycles, a far longer and riskier undertaking for code whose behavior had to stay identical.
Go also gave the team straightforward access to real parallelism, which the RC exposes through new flags. A checkers flag, defaulting to four, distributes type-checking work across workers, and a builders flag parallelizes project reference builds. The file watcher was rebuilt on the Parcel watcher, ported from C++ to Go. The lesson for engineering leaders is that the boring criterion often wins: the right language for a port is the one whose memory model matches the existing data structures, not the one with the best benchmarks in the abstract. Microsoft optimized for a faithful, shippable port, and the language choice followed from that.
What Hejlsberg Is Really Saying
Lead architect Anders Hejlsberg framed the effort around scale rather than speed for its own sake. "As your codebase grows, so does the value of TypeScript itself, but in many cases TypeScript has not been able to scale up to the very largest codebases," he said. That is a candid admission that the original compiler had hit a ceiling, and it reframes the whole project. The goal was not to make a fast tool faster; it was to remove a constraint that had quietly capped how large a TypeScript codebase could grow before the tooling became the bottleneck.
The pre-release testing roster underlines who that ceiling was hurting. Microsoft says Bloomberg, Canva, Figma, Google, Linear, Notion, Slack, and Vercel were among the companies validating the RC, and that feedback has been overwhelmingly positive, with many teams reporting they shaved off a majority of their build times. These are organizations whose monorepos had grown to the point where type checking was a measurable tax on every commit. The RC tells them that tax is about to fall by an order of magnitude, which changes the calculus on how much they can centralize into a single typed codebase.
How to Plan the Migration
Because TypeScript 7.0 preserves type-checking semantics, most teams can treat the upgrade as a CI and tooling change rather than a code change. The frictions are at the edges: the RC ships stricter configuration defaults, with strict mode on, an empty types array, and several deprecated options removed, so projects leaning on loose legacy settings should expect to adjust their tsconfig. The programmatic API, which build tools and editor plugins depend on, is not stable until TypeScript 7.1, expected several months out. Tooling authors should hold for that; application teams should not.
Our recommendation is to pilot the RC now in CI on a representative repository, measure the wall-clock change on type checks and language server responsiveness, and use those numbers to justify the rollout. The payoff compounds: faster checks mean tighter feedback loops, cheaper CI minutes, and the practical option to keep more code under one typed roof rather than fragmenting to dodge slow builds. With general availability roughly a month out, the prudent move is to be ready, not to be early. The order-of-magnitude speedup is real, and it will reset expectations for what TypeScript at scale should feel like.
