The Ten-Second Compile: TypeScript’s Biggest Change in a Decade

How many times have you hit save, glanced at that little spinner next to your terminal, and felt the familiar twitch of impatience creep in? Maybe you got up for coffee. Maybe you scrolled your phone “just for a second” and lost ten minutes you’ll never get back. If you’ve spent any real time in a large TypeScript codebase, you know that twitch well. Waiting on the compiler isn’t just an inconvenience — it’s a daily tax on your focus.

That’s exactly the problem TypeScript 7.0 was built to solve, and it solves it in the most direct way possible: by rewriting the entire compiler from scratch in Go.

Why This Isn’t Just Another Version Bump

For over a decade, TypeScript did something almost poetic — it checked itself. The compiler was written in TypeScript, compiled down to JavaScript, and run on Node. Elegant, sure. But it also meant TypeScript inherited every one of JavaScript’s limitations: single-threaded execution, garbage collection pauses, the lot. On a small project, you’d never notice. On a codebase with a couple million lines, you’d feel it every single day.

TypeScript 7.0, which reached general availability in July 2026 after a project internally known as “Project Corsa,” breaks that pattern entirely. The new compiler is written natively in Go, and the results aren’t subtle. Microsoft’s own benchmark on the VS Code codebase — roughly 1.5 million lines — showed a full type-check dropping from 125.7 seconds to 10.6 seconds. That’s not a nice-to-have improvement. That’s the difference between a genuine break in your thinking and a blink.

What This Actually Means For You

Wouldn’t it be great to trust that your build will just… finish, before your train of thought derails completely? That’s the real gift here. Faster builds aren’t only about CI pipelines humming along quicker, though they do that too. They’re about protecting the thing that’s hardest to get back once it’s gone: your concentration.

Think about what changes when the feedback loop shrinks that dramatically:

• REGAIN your flow state instead of losing it to a spinner
• CATCH errors the moment you make them, not minutes later
• RUN larger type-checks without dreading the wait
• SCALE your codebase without watching your tooling buckle under it

Remember: a faster compiler isn’t just a performance win on a chart somewhere. It’s fewer moments where your brain quietly checks out of the problem you’re solving.

A Few Things Worth Knowing Before You Jump In

Now, I won’t pretend this upgrade is entirely frictionless, and I think it’s worth being honest about that rather than glossing over it. TypeScript 7.0 shipped without a stable programmatic API, which means tools like Vue’s Volar, Svelte, and Astro’s type checker are still waiting on a later release before they can fully catch up. If your stack leans on one of those, it’s worth holding off just a little longer.

But on the other hand, if you’re working in a fairly standard setup, there’s very little reason to wait. Strict mode is now the default, some legacy build targets have been retired, and installation is refreshingly simple — just the standard install command, no special flags required.

The Bigger Picture

This release matters because it signals something beyond raw speed: TypeScript is willing to rebuild its own foundation when the old one starts holding developers back. That’s the kind of decision that pays off for years, not just for one release cycle.

So the next time you hit save and the compiler finishes before you’ve even looked away from your screen, take a second to notice it. That small, quiet moment of not waiting is exactly what this whole rewrite was for.

Categorised in: Typescript

This post was written by Prem