For a decade the joke about a big TypeScript codebase was that you could go make coffee while tsc thought about it. On July 8, Microsoft shipped the version that ends the joke: TypeScript 7.0, the compiler rewritten from JavaScript into Go, is stable — and it is roughly ten times faster.
That headline is true, and it is not the interesting part. The interesting part is the sentence Microsoft buried under it: 7.0 does not yet ship a stable programmatic API. If you build on Vue, Svelte, Angular, or you run typescript-eslint — which is nearly everyone — that one omission decides how much of the 10x you actually get this quarter.
What actually shipped#
The rewrite is real, not a marketing reskin. Over the past year the team ported the compiler from its old bootstrapped-TypeScript form to native Go, and the speedup comes from two places at once. Anders Hejlsberg's framing, repeated across the release coverage: about half the win is simply being native code instead of JavaScript, and the other half is shared-memory concurrency — 7.0 runs parsing, type-checking, and emit in parallel, which the single-threaded JS compiler structurally could not.
The numbers Microsoft published are not subtle. Its tested range is 8–12x, and its own flagship is the proof of work: VS Code's codebase drops from 125.7 seconds to 10.6 seconds on a full type-check — call it 11.9x. The team also cites validation runs with Slack, Figma, and Google, and a language server that crashes 60%+ less often. For a 1.5-million-line repo that used to take 78 seconds, 10x is the difference between "switch tabs and lose the thread" and "the red squiggles are just there."
The 10x isn't a benchmark trick you have to chase with special flags. It's the default now. The question isn't whether your tsc runs get faster — it's whether the tools you actually type against can reach the new compiler yet.
The catch everyone skims past#
Here is the load-bearing caveat. TypeScript 7.0 ships without a stable programmatic API. The library surface that lets other software drive the compiler — feed it files, ask it to type-check, read back diagnostics — is deferred to 7.1.
That sounds like an internal detail. It is not, because a huge amount of the toolchain you rely on is exactly that kind of consumer:
- Vue (
vue-tsc), Svelte, Astro, and MDX type-check templates by calling into the compiler as a library. - Angular's template type-checking does the same.
typescript-eslint— the thing that makes ESLint understand types at all — is a compiler consumer end to end.
None of them can simply flip a version number and inherit the speedup, because the API they call doesn't exist in 7.0 yet. Until 7.1 lands and each project adopts the new interface, framework-heavy type-checking stays on the 6.0 path. So the honest expectation for a Nuxt or SvelteKit shop is split: your bare command-line tsc and CI type-check step can be 10x today, while the editor experience inside your framework files — the squiggles that come from vue-tsc or the ESLint type rules — moves on a slower clock. Plan around that gap instead of being surprised by it in a sprint.
Why 6.0 mattered more than it looked#
If you treated TypeScript 6.0 as a skippable point release back in the spring, this is where it bites. 6.0 was never really about new features — it was the migration bridge to the Go compiler. It shipped as the last JavaScript-based release specifically to soften the jump: it turned everything that becomes a hard error in 7.0 into a visible deprecation warning first, and it flipped the defaults 7.0 assumes — strict on, module to esnext, target to the latest supported spec, and types to an empty array instead of hoovering up every package in node_modules/@types.
The payoff of that design is a clean promise: code that compiles cleanly under 6.0, without reaching for ignoreDeprecations, should compile identically under 7.0. If you did that work, 7.0 is a speed upgrade, full stop. If you skipped 6.0, then 6.0 — not 7.0 — is your actual migration, and you do it now, with the warnings on, before you chase the fast binary.
The move for a small team this week#
You do not have to pick a side. Microsoft shipped @typescript/typescript6, a compatibility package with a tsc6 executable that re-exports the 6.0 API. That's the seam:
- Point your CI type-check and command-line
tscat 7.0 now. That's where the wall-clock pain lived, and it's the part with no ecosystem dependency — pure win. - Keep 6.0 (via
tsc6) wherever a framework plugin or linter still needs the old programmatic API, and let those tools migrate to 7.1 on their own timeline. - Watch for 7.1. When the stable API lands and
vue-tsc, the Svelte and Astro toolchains, andtypescript-eslintadopt it, the second half of the speedup — the part you feel while typing — arrives.
The one-line version, the one worth quoting to a co-founder who's about to greenlight a Friday-afternoon upgrade: the 10x is here and it's honest, but in 2026 "TypeScript is fast now" is a statement about your build server, not yet about your editor. The build server is the easy half. Bank it today; put 7.1 on the calendar for the rest.
