TypeScript 7 RC is here: your build just got 10× faster (and why that changes everything)

TL;DR

Microsoft shipped TypeScript 7 RC — the tsc compiler rewritten (technically ported) from TypeScript to Go.
Reported speedup: ~10× on typical projects. Real numbers across Bloomberg, Canva, Figma, Google, Microsoft internal teams during the 12-month private beta.
Editor loop and CI both benefit — tsc runs on both. Faster tsc = faster type errors in your editor + faster builds in CI.
Breaking changes exist. TypeScript 7 hardens 6 defaults and removes deprecated flags. Adopt TS 6 first if you're on ≤5.x to soften the jump.
Bigger implication: JavaScript tooling written in JavaScript is over. Bun (Zig→Rust), esbuild (Go), swc (Rust), Oxc (Rust), Vite (Rust internals), and now tsc (Go) — the pattern is set.

What's actually different

The v6 compiler was TypeScript written in TypeScript, running on Node.js/V8. Type-checking is CPU-bound: build the import graph, build the AST, resolve types, propagate through generics. Node.js has worker threads and child processes, but CPU-bound parallelism in a JS runtime is fundamentally cramped compared to a language with first-class threads.

The v7 compiler is the same TypeScript compiler, ported to Go. Same semantics, same behavior, same test suite it's always been tested against. The wins come from three places:

Statically compiled, natively parallel. Go schedules goroutines across cores cheaply. Type-check work fans out where before it serialized.
AOT compilation vs V8 JIT. Once you're doing CPU-heavy work for seconds, JIT warmup is a wash — the AOT binary wins.
Tighter data structures. Go structs + value semantics vs V8 object shapes + GC pressure at scale. On multi-thousand-file codebases this shows up.

Microsoft's claim on Bloomberg/Canva/Figma-scale codebases: majority of build time gone. My own quick test (Claude Code generated an 8000-module synthetic project with recursive generics): 19.4s on TS 5.x → 3.48s on TS 7 RC. That's 5.6× on a project small enough to run in a minute. Big monorepos will see the full 10×.

Why tsc matters more than your runtime

You might be thinking: "I already run TypeScript with Bun / Node.js native TS support / esbuild." Right — but those tools execute TypeScript. They don't type-check it.

Try this:

const a: number = 10
const b: string = 20 as any as string
console.log(a + b)

Run it with Bun, run it with Node (--experimental-strip-types), transpile with esbuild. All three say "yep, fine, runs." The output is nonsense at runtime, but nothing complained.

Only tsc complains. Only tsc catches the actual type error. That's the point of TypeScript — the type check.

Every editor you use (VS Code, Cursor, Zed, JetBrains) runs tsc as the language server under the hood to show you red squiggles. Your editor's TypeScript feedback loop just got 10× faster. That's the daily-work win. CI builds getting faster is nice; the editor loop is life-changing.

What ships

Six hardened defaults in TS 7 (already the recommendation in TS 6):

Flag	New default	Why
`strict`	`true`	Should have been forever
`module`	`esnext`	Modern module resolution
`target`	Current stable ECMAScript version preceding esnext	Modern JS
`noUncheckedSideEffectImports`	`true`	Catches typos in imports
Plus 2 more	Various strict-mode implications	See release notes

Deprecations that are now errors (not warnings):

target: ES5 — gone. If you're targeting IE11 in 2026, you have bigger problems.
Down-level iteration flag — gone.
baseUrl — gone. Use path mapping via paths instead.
Several more; check the release notes.

Migration path: adopt TS 6 first if you're on 5.x. TS 6 already flipped most of these defaults + warns on the deprecations. TS 7 turns those warnings into errors. Sequential migration is significantly easier than the jump from 5 → 7 directly.

Where this doesn't apply

Watch mode / hot-reload edit-loop latency — already fast in TS 6 for small edits (incremental compile). TS 7's win is more pronounced on cold builds.
isolatedModules: true transpile-only builds — you're skipping tsc anyway. No change.
Projects fully on Bun / Node's native TS — tsc isn't in the hot path except for editor type-checking. Editor still wins.

The bigger pattern

Look at what tooling ships in what language in 2026:

tsc: TypeScript → Go (2026)
Bun runtime: Zig → Rust (2026)
esbuild: Go (since 2020)
swc: Rust
Oxc / oxlint: Rust
Vite's core bundler pieces: Rust migration underway
Biome: Rust (superset of what Prettier + ESLint do)
turbopack: Rust

The pattern is unambiguous. JavaScript tooling written in JavaScript is a legacy category. Not dying — TypeScript itself is fine, the runtime is fine, Node/Bun/Deno are fine. But the tools that operate on your JavaScript source are moving to systems languages, one by one, because the perf ceiling on JS-in-JS is real.

The winners: Go, Rust, Zig. The verb across all of them: port, don't rewrite. Same semantics, same tests, same compat surface. What changes is throughput.

What to do this week

Try TS 7 RC in a branch. pnpm add -D typescript@rc. Run your build. Note the time. Note any errors that TS 6 didn't throw — those are your migration surface.
If you're on TS ≤5.x, upgrade to TS 6 first. The 6-defaults will surface deprecations early; the 7 upgrade is trivial after.
In big monorepos, run tsc --extendedDiagnostics on both versions and compare Total time + Check time. The check-time gap is where the 10× lives.
Update CI. If your tsc --build step drops from 4 min to 30 s, other stages (lint, test, deploy) become the bottleneck. Retime the pipeline.

Ship it

TS 7 RC is stable. Bloomberg, Canva, Figma, Google, and Microsoft-internal teams have been running it in production for months. Microsoft's exact framing: "highly stable, highly compatible, and ready to be put to the test in your daily workflows and CI pipelines today."

That is not the phrasing of a nervous release. Take them at their word. Upgrade a branch, watch the numbers, ship the PR.

References:

TypeScript 7 RC announcement — Microsoft TypeScript team, 2026
Why we ported the compiler to Go — technical background, 2025
Six hardened defaults + deprecations list — official release notes