TypeScript 7 Just Shipped: I Checked Five Claims Going Around Against Microsoft's Own Numbers

TypeScript 7 went generally available on July 8, 2026. Within a day, the talking points had already calcified: 10x faster, half the memory, same compiler under the hood, just bump the version and go.

Some of that is true. Some of it is rounding a real number into a rounder, less accurate one. And one detail — the one that will actually cost teams engineering hours — barely made it into the first wave of coverage at all.

So instead of another "here's what's new" recap, here are the five claims already circulating, checked one at a time against Microsoft's own release post and the surrounding reporting. Verdicts below, in order of how much they matter to your Monday morning.

At a glance

Claim 1 · "It's roughly 10x faster"

Verdict: True — and in the best case, it undersells it.

Microsoft's own release post gives a real table, not a marketing bullet. Running TypeScript 6 against TypeScript 7 on five real open-source codebases, at the default setting of 4 parallel type-checker workers:

That's the conservative setting. TypeScript 7 ships a new --checkers flag that controls how many parallel type-checking workers run at once. Push it from the default of 4 to 8 on the same machine, and the VS Code build drops further — to 7.51 seconds, a 16.7x speedup over TypeScript 6.

The editor experience improved by a similar margin, and this is the number that will actually change how a build feels day to day. Opening a file with an error in the VS Code codebase used to take about 17.5 seconds before the first red squiggle appeared. In TypeScript 7, that's under 1.3 seconds — over 13x faster.

So "10x" isn't a rounded-up marketing number here. If anything, it's the floor.

Claim 2 · "It uses about half the memory"

Verdict: Overstated. The real number is a lot more modest — and still worth having.

This is the claim worth slowing down on, because it's a good example of how a real figure gets inflated as it travels between blog posts.

Microsoft's own GA-day benchmark table, on the same five codebases, shows full-build memory usage dropping between 6% and 26% — not 50%.

None of that is a knock on the release. An 18% memory cut on a full VS Code build, stacked on the 11.9x speedup from Claim 1, is a genuinely good trade for a CI runner with fixed RAM.

But "half the memory" and "18% less memory" are different claims, and only one of them is what Microsoft's own numbers show for a full build. The more dramatic memory story appears to live in steady-state editor sessions rather than full builds — and that distinction got flattened somewhere between the preview-era blog posts and the recaps that followed.

Claim 3 · "It's basically the same compiler, just written in Go now"

Verdict: True about behavior. Not even close to true about what it took to get there.

Start with what Microsoft actually promises: TypeScript 7 is a port, not a rewrite. The team moved the existing structure, algorithms, and logic from the old JavaScript-based compiler (retroactively named Strada) into Go, file by file, rather than redesigning the type-checker from scratch. The stated goal was that code compiling cleanly under TypeScript 6 should compile identically under TypeScript 7.

That faithfulness is exactly why the choice of Go over Rust is worth understanding, rather than shrugging off as a language preference. TypeScript's lead architect, Anders Hejlsberg, has said the team evaluated Rust, C++, and Microsoft's own C# first.

Rust was ruled out for a structural reason, not a taste one. The compiler's internal representation — its abstract syntax trees and symbol tables — is full of cyclic references. Rust's ownership model makes that kind of cyclic structure genuinely painful to express without a garbage collector, which would have forced a redesign of the type-checker's core data model before any porting could start.

Go's garbage-collected, shared-memory model maps directly onto the existing shape: cyclic references just work, and goroutines give cheap parallelism across a single symbol table without redesigning anything.

C# lost out for a different reason. The existing codebase leans heavily functional with minimal use of classes, and Hejlsberg has said C#'s more object-oriented model was a worse structural fit than Go's function-and-struct approach.

The choice was not universally popular. It spilled across Hacker News, Reddit, and a long GitHub discussion thread, much of it from C# developers asking why Hejlsberg passed over his own language. His answer has been consistent throughout: Go was the lowest-level option that offered native-code performance, fine control over memory layout, cyclic data structures, and mature garbage collection, all at once.

There's a quieter cost buried in all of this that outlasts the language debate. For essentially its entire existence — roughly 14 years — the TypeScript compiler was self-hosted: written in TypeScript, compiling itself. That's over now. The compiler that checks your types is written in a language your types aren't written in, and contributing to it now requires knowing Go, not TypeScript.

For almost everyone who just uses TypeScript, this changes nothing about your day. For the smaller group who used to read the compiler's own source as a way of learning advanced TypeScript, that specific on-ramp just closed. It's a real if narrow loss — and it's the kind of detail a release note built around benchmark charts has no reason to mention.

Claim 4 · "You can just bump the version number and move on"

Verdict: For some teams, yes. For others, this is the claim that will eat your week.

This is the one first-look coverage most underserved, because it's not really about speed at all.

Before TypeScript 7, tsc was a JavaScript library living in your Node process. Tools called straight into it: ts-jest called ts.transpileModule(), typescript-eslint called ts.createProgram() to build a full language service, ts-morph walked the type graph through ts.createCompilerHost(), and ts-node hooked Node's module loader and delegated directly to the compiler.

TypeScript 7's compiler is a separate Go binary — the payoff of the port described in Claim 3. It doesn't live in your Node process anymore.

Anything built on "import typescript and call a function" is now talking to something that no longer exists in that form, and the failures rarely announce themselves as a TypeScript problem. A broken ts-node setup, for instance, tends to surface as an ESM configuration error — which sends people debugging the wrong layer for a while.

Three groups of tools are affected differently, and it's worth knowing which one you're in:

• Custom AST transformer plugins (ts-patch, ttypescript, typia, and similar) have no JavaScript plugin surface left to call into. There's no clean patch; the real fix is moving transforms to something like SWC or Oxc and letting the Go compiler handle type-checking only.

• Tools that hook the module loader — ts-node being the clearest case — delegate to a JavaScript tsc that no longer exists in the expected form.

• Tools built on the programmatic Compiler API (typescript-eslint, ts-morph) are fine for now, but only because Microsoft explicitly deferred this problem. TypeScript 7.0 ships with no stable API at all. That's coming in 7.1, still some months out.

To bridge that last gap, Microsoft published a compatibility package, @typescript/typescript6, which installs a tsc6 executable and re-exports the old TypeScript 6.0 API. The intended pattern is an npm alias: point typescript at the 6.0 compatibility package for tools that still need the old API, and add a separate alias so tsc resolves to TypeScript 7 for your own build and CI steps.

Tools that never depended on the Compiler API in the first place — Biome and esbuild among them — are simply unaffected, since they ship their own parsers.

If you're on Vue, MDX, Astro, Svelte, or Angular's Volar-based tooling, you're stuck on TypeScript 6.0 for editor support specifically, since those tools embed TypeScript's own API into their language services and that API doesn't exist yet in 7.0. Microsoft's release notes say this plainly rather than glossing over it.

There's also a tsconfig layer to this claim. TypeScript 7 hard-adopts TypeScript 6.0's newer defaults and turns a decade of soft deprecations into flat errors:

Two language-level changes rode along with the tooling shift, and they're worth knowing about even if they're narrow. Template literal type inference now treats a multi-byte character like an emoji as one unit instead of splitting it into a UTF-16 surrogate pair, which breaks any type-level string utility that leaned on the old behavior. And TypeScript's JSDoc-based JavaScript support was reworked to match .ts semantics more closely, changing how older patterns like @enum and Closure-style function types get interpreted.

So: if your stack is tsc and nothing else, this claim is basically true. If it includes any of the tools above, it's the opposite of true — and the failure mode looks like a config bug rather than a version bump.

Claim 5 · "This is still experimental, not proven at real scale"

Verdict: False. This has already been run hard, by people with a lot to lose.

Beyond Microsoft's own large internal codebases (Loop, Office, PowerBI, Teams, Xbox), the company says it spent the past year working with Bloomberg, Canva, Figma, Google, Lattice, Linear, Miro, Notion, Sentry, Slack, Vanta, Vercel, and VoidZero — the team behind Vite, Rolldown, and Oxc — on pre-release builds of TypeScript 7.

Some of the reported numbers are specific enough to be more than a testimonial slide:

Slack's editor had reportedly gotten slow enough that engineers were leaning on CI for full type-checks instead of trusting the local language server.

Microsoft also reports that the new language server cut failing language-server commands by more than 80% and crashes by more than 60%, compared to TypeScript 6's. That's a meaningful reliability claim stacked on top of the speed one.

Worth flagging plainly: every number in this section is Microsoft measuring Microsoft's software, plus companies Microsoft chose to name. It is not an independently replicated audit, and it would be a mistake to read it as one. But "not proven at scale" doesn't hold up either — this is a different category of evidence than a beta announcement with a demo gif.

So — should you upgrade this week?

• If your usage is limited to running tsc for type-checking and builds — upgrade now. That's the scenario Microsoft optimized for first, and it carries the least ecosystem risk of anything on this list.

• If your pipeline includes typescript-eslint, ts-morph, ts-node, ts-patch, ttypescript, or a custom transformer — don't do a blind upgrade. Use the npm alias pattern: TypeScript 7 for your own tsc invocations, the 6.0 compatibility package for anything still calling the old API, until either the tool updates or TypeScript 7.1 ships its stable API.

• If you're on Vue, Astro, Svelte, MDX, or Angular — stay on TypeScript 6.0 for editor tooling for now. You can still get the CLI type-check speed from TypeScript 7 without touching your editor's language server plugin.

Either way: don't take my word, Microsoft's word, or anyone else's for the speedup on your specific codebase. npx tsc --version tells you what you're running, and installing TypeScript 7 alongside your current setup via an alias costs nothing to try before you commit.

Sources

1. Microsoft — Announcing TypeScript 7.0 (July 8, 2026)

2. Microsoft — Announcing TypeScript 7.0 RC (June 18, 2026)

3. Microsoft — Progress on TypeScript 7 – December 2025

4. microsoft/typescript-go — Why Go? (GitHub Discussion #411)

5. The New Stack — Microsoft TypeScript Devs Explain Why They Chose Go Over Rust, C#

6. DevClass — TypeScript inventor Anders Hejlsberg: AI is "a big regurgitator of stuff someone has done"

7. BeyondIT — Three Tools in Your TypeScript Stack Will Break on the 7.0 Upgrade

8. webhani — Preparing for TypeScript 7.0: Breaking Changes and Migration Steps

9. Visual Studio Magazine — TypeScript 7.0 RC Moves Microsoft's Go Rewrite Into the Mainline Compiler

10. Neowin — Microsoft releases TypeScript 7.0, and it's 10x faster than the previous version