TypeScript 7.0 Released: Go Rewrite, 10x Faster

Microsoft has officially released TypeScript 7.0, the version that replaces the compiler’s original JavaScript/TypeScript implementation with a complete rewrite in Go. The company reports the native port is often roughly 10x faster than TypeScript 6.0, turning multi-minute type-checks on large codebases into single-digit-second runs. The release landed on July 8, 2026, capping a rewrite Microsoft first previewed under the internal name “Corsa” more than a year earlier and moved into the mainline compiler through a June release candidate.

Why Microsoft rewrote the compiler in Go

The headline is speed, and the speed comes from the language change. The original compiler was itself written in TypeScript and ran on a JavaScript engine — a design that made the codebase approachable but capped how fast it could go and, critically, kept it single-threaded. Rewriting the compiler as a native Go binary removes both limits at once: native code runs faster per operation, and Go’s concurrency model lets the compiler do genuinely parallel work.

That parallelism is the structural change underneath the 10x number. TypeScript 7.0 now performs many stages — parsing, type-checking, and emitting — across multiple threads rather than in a single pass. The release adds new controls to expose that: --checkers sets the number of type-checker workers, --builders governs parallel project-reference builds, and --singleThreaded forces the old single-threaded behavior when you need deterministic, sequential runs for debugging.

The payoff is concentrated where it hurts most today: large monorepos and CI pipelines, where type-checking a big project could dominate build time. Shrinking that from minutes to seconds changes the economics of running tsc on every commit — and makes editor responsiveness in VS Code noticeably snappier, since the language service that powers autocomplete and error squiggles rides on the same engine.

What breaks in the upgrade

A rewrite this deep is not free of friction, and TypeScript 7.0 uses the major-version bump to shed accumulated baggage. The breaking changes cluster around defaults and dropped legacy support:

• strict and esnest-style modern defaults are now hard requirements, not opt-in flags. Projects that leaned on loose settings will need to reconcile with stricter checking.
• Deprecated flags and older module-resolution modes are gone. Configurations that targeted ancient JavaScript output or relied on legacy resolution behavior will fail until updated. TypeScript 6.0 spent its cycle warning about these; 7.0 removes them.
• Programmatic API consumers should wait. Tools that call into the compiler’s internal API — bundlers, linters, and type-aware frameworks — depend on interfaces that are still stabilizing. Microsoft has flagged TypeScript 7.1 as the target for stable programmatic APIs.

To ease the transition, teams can run the old and new compilers side by side using the @typescript/typescript6 compatibility package, keeping a known-good 6.x build in place while validating 7.0 across the codebase. The recommended install path is the standard package — npm install -D typescript — with the tsc binary now being the Go-native compiler rather than a separately named tool.

The bigger picture: native tooling is winning

TypeScript 7.0 is the most prominent entry in a broader migration of JavaScript tooling away from JavaScript itself and toward native, compiled languages. The pattern is now unmistakable across the ecosystem. Vercel’s Turbopack, written in Rust, became the default bundler in Next.js 16. The Vite team has been building Rolldown, a Rust-based bundler, to replace its JavaScript-and-esbuild pipeline. Linters, formatters, and package managers have followed the same path.

The logic is consistent: the tools that developers run hundreds of times a day sit on the critical path of every edit-save-check loop, and shaving seconds there compounds into real productivity. JavaScript is an excellent language for the applications these tools build, but a poor fit for the tools themselves, where raw throughput and multi-threading matter more than ergonomics. Microsoft choosing Go rather than Rust — partly to keep the port close in structure to the original TypeScript source and ease the translation — is a pragmatic footnote to that larger trend.

Native TypeScript everywhere

The compiler rewrite arrives alongside a second shift that has quietly changed how TypeScript is run: the major runtimes now execute it directly, without a separate build step. Node.js enabled type stripping by default in recent 22.x releases, so .ts files run natively without the --experimental-strip-types flag. Deno and Bun have supported TypeScript natively for some time.

Type stripping and full type-checking are different jobs — the runtimes erase types to run your code, while tsc still verifies them — but together they collapse a lot of the old ceremony. A developer in 2026 can write TypeScript, run it directly in Node, and get a 10x-faster full type-check in CI, without a hand-configured build pipeline in between. Adoption has kept pace: surveys put TypeScript usage among professional developers at 78% in 2026, up from 69% in 2024, with a growing share writing it exclusively.

How to approach the upgrade

For most teams, the calm path is the incremental one. Pin the @typescript/typescript6 compatibility package so nothing breaks on day one, then run 7.0 against the codebase in CI to surface the strictness and resolution errors the new defaults expose. Fix those on your own schedule, and only cut over the default tsc once the build is clean. Framework and bundler authors dependent on the programmatic API have a stronger reason to wait for 7.1, where those interfaces stabilize.

What it means

TypeScript 7.0 is the rare major release whose value is almost entirely about speed rather than new syntax — and that is exactly why it matters. Type-checking has been the slowest, least-parallel step in many JavaScript build pipelines for years, and a 10x cut removes a tax that every large TypeScript project has been paying on every commit.

Who benefits. Teams with big monorepos and slow CI gain the most immediately: faster type-checks mean cheaper pipelines and shorter feedback loops. Everyday developers benefit more subtly through a more responsive editor, since the language service shares the new engine.

Who has to do work. Anyone with a codebase built on loose settings or legacy module resolution will hit the stricter defaults and dropped flags, and tooling authors who call the compiler’s internal API must wait for 7.1. The compatibility package makes the migration survivable, but it is a migration, not a drop-in bump.

What to watch. The real signal is whether the native-tooling wave now reaches the last JavaScript-based holdouts in the toolchain. With the Astro, Next.js, and Vite ecosystems already moving to Rust-based cores and TypeScript’s own compiler now in Go, the era of JavaScript build tools written in JavaScript is closing. The next question is how fast the stable programmatic APIs in 7.1 arrive — because that is what unblocks the rest of the ecosystem to build on the faster foundation.