Inside TypeScript 7: What a Year-Long Rewrite in Go Actually Bought Developers

Somebody at Microsoft made a promise about a year ago: they were going to rip TypeScript's compiler out of JavaScript, rebuild it natively in Go, and make it roughly ten times faster. That's the kind of number that gets thrown around in keynote slides and dies quietly in production. Big promises are cheap. What's not cheap is a year of your own flagship product's engineering team actually living with the thing, daily, in public, with nowhere to hide when it broke.

That's what happened here. And it's worth walking through in detail, because the interesting part isn't the number — it's what it took to earn it.

Why the Old Compiler Couldn't Just Get Faster

TypeScript's compiler used to run on top of JavaScript. That was never a design flaw exactly — it made sense for a language built to layer on top of JavaScript in the first place — but it meant every type check, every compile, every editor suggestion was paying an overhead tax that had nothing to do with the actual work being done. Fine for a small project. Brutal once you're checking a codebase the size of a mid-sized company's entire product line.

The fix Microsoft landed on wasn't incremental. It was a full native port to Go — new code, same underlying logic and structure as the original, written specifically so the two compilers would keep producing matching results. That's a harder discipline than a clean rewrite. A clean rewrite lets you cut corners and call it progress. This was closer to a faithful translation, done under the constraint that nothing downstream could break.

Where the Speed Actually Comes From

Native code is faster than interpreted code — that part's just physics, nothing clever about it. The genuinely interesting engineering happened somewhere else: parallelization that the old architecture never allowed.

Type-checking a large codebase used to be a single continuous pass, one thread, start to finish. TypeScript 7 spins up multiple independent checker workers that split the codebase and work at the same time. They're not perfectly coordinated — there's some duplicated effort, work getting redone across workers — but the results match what a single-threaded pass would produce, just delivered faster. You control how many workers run; more of them means more speed, but also more memory and CPU pressure, so it's a real dial, not a free lunch.

Large monorepos get a parallel treatment with independent builder workers, and here's the part worth flagging for anyone about to crank every setting to maximum: checker workers and builder workers compete for the same resources. Overload one side and you can choke the other. Tuning this stuff matters.

The Team That Had to Eat Its Own Cooking

Here's where this stops being a compiler story and starts being a story about how you actually validate something this disruptive: Microsoft handed an unfinished version of TypeScript 7 to its own Visual Studio Code team, more than a year before the public release.

That's not a small ask. VS Code is one of the largest TypeScript codebases in existence, and it's also the primary home for TypeScript's own tooling — the language server, the debugging integration, the autocomplete engine all live inside it. So this wasn't an isolated pilot program off in a corner somewhere. It was the compiler being tested by the team most exposed to its failures, on the product most people associate with TypeScript's daily experience.

They didn't flip a switch and hope. The rollout was staged, deliberately conservative:

They started with lower-stakes extensions, running daily builds of the new compiler so bugs surfaced fast and stayed contained before they could spread. Microsoft, meanwhile, was building a native preview of the TypeScript 7 extension for VS Code in parallel, shaped by exactly the bug reports coming back from that daily use.

Then came the bridge: TypeScript 6. Rather than leap straight from the old compiler to the new one, the VS Code team migrated first to TypeScript 6, which shared the same language changes as 7 but ran on the familiar JavaScript-based compiler. That let them validate their code against the new language features and pick up some incremental speed gains — nowhere near the full native jump, but enough to build real confidence before the harder move. It's a pattern any team taking on a risky migration should steal outright: find the intermediate step that lets you fail small before you're forced to fail big.

By late 2025, VS Code development had shifted onto TypeScript 7 itself, with TypeScript 6 held in reserve as a fallback. Issues that turned up got reported straight back to the TypeScript team, which used them to prioritize what got fixed next. By early 2026, the compiler was stable enough that the VS Code team started building all of its own built-in extensions on it — and while they were in there, they also swapped their bundler from webpack to the one built into esbuild, squeezing out another round of gains.

What a Year of Real Use Actually Delivered

Numbers, stripped of the marketing framing:

• Type-checking the full VS Code codebase: 7x faster, with most individual extensions checking in under a second.
• The one holdout: the GitHub Copilot extension, nearly as large as the editor itself, which still checked in around 2.5 seconds — a reminder that even a dramatically faster compiler doesn't erase the cost of genuinely large surface area.
• Full compilation time: down from roughly 80 seconds to about 20.
• Language server project load — the step underlying error detection and refactoring — down from around a minute to about 10 seconds.
  None of those numbers is individually dramatic. What's dramatic is compounding them across a team the size of VS Code's, across every save, every build, every refactor, every single day. That's not a benchmark win. That's the difference between staying in flow and constantly getting knocked out of it.

The Migration Path for Everyone Else

TypeScript 7.0 ships without a full programmatic API — that's coming later, with 7.1 — which matters if your own tooling reaches directly into the compiler's internals. Microsoft's answer is a compatibility package, @typescript/typescript6, which installs an executable called tsc6. Point your existing TypeScript-6-API-dependent tooling at tsc6, keep tsc free for the new compiler, and both versions run side by side while you migrate on your own timeline. You'll likely need npm aliases to keep linters and other lower-level tools pointed at the right version, and possibly two separate dependencies declared in package.json — not elegant, but functional, and it buys real time.

What This Actually Means for You

The headline number was never really the story. What matters is that the team with the most to lose from a broken compiler ran it in production for over a year before the rest of the world got a copy — and came out the other side with concrete, compounding gains instead of vague enthusiasm. If you're planning your own migration, the VS Code path is the template: stage it, use TypeScript 6 as your bridge, and don't assume your tooling survives the jump to a new API without checking first.

The final release landed this month. If you haven't pulled up the release candidate yet, that's the actual next step — not reading about someone else's numbers, but generating your own.