TypeScript 7.0 — released July 8, 2026 — is a native Go port of the TypeScript compiler and language service that delivers 8x to 12x faster full builds and a ~13x faster editor error response, with no breaking language changes. On the VS Code codebase (1.3 million lines across roughly 8,000 files), a complete type-check dropped from 125.7 seconds to 10.6 seconds — an 11.9x speedup — and to 7.51 seconds with the new --checkers 8 flag, a 16.7x improvement over TypeScript 6.
If your team runs TypeScript at scale, the practical payoff is twofold: CI minutes shrink (Slack cut type-checking from ~7.5 minutes to 1.25 minutes and reduced merge-queue time 40%) and the in-editor squiggly-line wait disappears (first-error visibility on big repos fell from ~17.5 seconds to under 1.3 seconds).
Last verified: 2026-07-31 · Build speedup 8x–12x (default flags), up to 16.7x with
--checkers 8· Language server failures −80%, crashes −60% · No programmatic API until 7.1 · Pricing/limits re-check monthly.
Why does TypeScript 7 need a Go rewrite at all?
TypeScript's old compiler and language server were written in TypeScript, running on a single JavaScript thread. For a decade that was fine, because JavaScript engines (V8 in particular) JIT-compile aggressively. But two structural ceilings made it impossible to keep scaling on a single core.
First, JavaScript is single-threaded for CPU-bound work. An async/Promise.all-style loop looks parallel but still executes sequentially on one thread, so looping over thousands of AST files and walking them concurrently does not actually divide work across cores. Anders Hejlsberg, the creator of C# and a Technical Fellow at Microsoft, described the constraint plainly: JavaScript engines are optimized for UI and browser workloads, not for compute-intensive compiler passes.
Second, Web Workers do not share objects between threads. You can only pass raw bytes across them (SharedArrayBuffer), which means handing a parsed abstract syntax tree to a worker requires serializing the whole structure, copying it, and rebuilding it on the other side. For a large source file, the serialization overhead frequently costs more than the work itself.
Go removes both ceilings at once. It compiles to native machine code that runs directly on the CPU, and its goroutine scheduler gives you shared-memory multithreading with objects passed by reference across cores. Microsoft's own engineering post attributes roughly half the speedup to native code and the other half to shared-memory concurrency. You can read the full design rationale in the TypeScript-go design notes and the official announcement.
How fast is TypeScript 7 — verified benchmark numbers
The numbers below are Microsoft's own published benchmarks from the TypeScript 7.0 announcement, run on the same hardware for fair comparison.
Full-build speed (default flags)
| Codebase | TypeScript 6 | TypeScript 7 | Speedup |
|---|---|---|---|
| vscode (1.3M LOC) | 125.7 s | 10.6 s | 11.9x |
| sentry | 139.8 s | 15.7 s | 8.9x |
| bluesky | 24.3 s | 2.8 s | 8.7x |
| playwright | 12.8 s | 1.47 s | 8.7x |
| tldraw | 11.2 s | 1.46 s | 7.7x |
The pattern matters more than any single row: the bigger the codebase, the bigger the relative win. VS Code, the largest of the benchmarks, sees the largest multiplier.
Build speed with --checkers 8
TypeScript 7 splits type-checking across a configurable number of worker goroutines. The default is 4. Bumping it to 8 buys another ~30% on multi-core machines.
| Codebase | TypeScript 6 | TypeScript 7 (--checkers 8) |
Speedup |
|---|---|---|---|
| vscode | 125.7 s | 7.51 s | 16.7x |
| sentry | 139.8 s | 12.08 s | 11.6x |
| bluesky | 24.3 s | 2.01 s | 12.1x |
| playwright | 12.8 s | 1.16 s | 11x |
| tldraw | 11.2 s | 1.06 s | 10.6x |
Memory usage actually goes down, not up
A native rewrite could have ballooned memory. It didn't — Go's runtime and the rewritten data-structures trimmed peak memory on every measured codebase:
| Codebase | TypeScript 6 | TypeScript 7 | Memory delta |
|---|---|---|---|
| vscode | 5.2 GB | 4.2 GB | −18% |
| sentry | 4.9 GB | 4.6 GB | −6% |
| bluesky | 1.8 GB | 1.3 GB | −26% |
| playwright | 1.0 GB | 0.9 GB | −11% |
| tldraw | 0.6 GB | 0.5 GB | −15% |
For CI/CD environments where every megabyte of RAM is a line item, that lower memory footprint compounds the speedup — you build faster and spin up smaller runners.
Editor / language-server speed
On the VS Code codebase, the time to show the first error after opening a file dropped from roughly 17.5 seconds to under 1.3 seconds — a 13x improvement. That is the single biggest daily quality-of-life win: you open a file, change a line, and the squiggles arrive in milliseconds instead of after lunch.
The new Go language server is also more stable. Compared to TypeScript 6.0 it has:
- Reduced failing language-server commands by over 80%
- Reduced server crashes by over 60%
The "restart VS Code because TypeScript stopped working" tax largely disappears.
How to install and run TypeScript 7 in 2026
The install path is intentionally minimal — the npm package itself got upgraded, there's no separate SDK to install.
# Standard per-project install (now gives you TypeScript 7)
npm install -D typescript
# Verify
npx tsc --version # prints 7.0.x or later
For full setup, including per-project, global, NuGet, and Visual Studio routes, see the official TypeScript download page.
VS Code requires the TypeScript 7 extension
By default VS Code's built-in TypeScript engine still ships with TypeScript 6 for compatibility. To get the Go-powered language server you need to install the dedicated "TypeScript 7" extension from the Marketplace. After that, opening any workspace that depends on typescript@7 will pick up the native server automatically. Visual Studio (the full IDE) enables TS 7 automatically based on the workspace — no extension needed. (Source: the official announcement.)
--checkers and --builders lets you scale to your CPU
Two new experimental flags let you spend extra cores for more speed:
--checkers N— sets the number of parallel type-checker workers. Default is 4. Raise it on a many-core machine for faster builds at the cost of more memory; set it to1to fall back to single-threaded type-checking (useful for reproducing order-dependent results).--builders N— controls the number of parallel project-reference builders under--build. Useful for monorepos. It multiplies with--checkers, so--checkers 4 --builders 4can spawn up to 16 concurrent type-checkers.
# Run the fastest possible full build on a 12-core laptop
npx tsc --checkers 12
# Monorepo with project references — parallel builders + checkers
npx tsc --build --checkers 4 --builders 4
Is TypeScript 7 a port or a rewrite — and does it still behave like TypeScript?
This is the question that decides whether the upgrade is safe.
TypeScript 7 is a faithful port, not a from-scratch rewrite. The TypeScript team re-implemented the existing compiler's structure and logic in Go, deliberately preserving behavior, ordering, and edge-case handling to keep results compatible with the JavaScript implementation. You should see identical type-checking output on the same codebase — only faster.
Microsoft validated this by running the new compiler against tens of thousands of tests and against real production codebases at companies including Bloomberg, Canva, Figma, Google, Lattice, Linear, Miro, Notion, Sentry, Slack, Vanta, Vercel, and VoidZero.
What's the catch — what doesn't ship in 7.0?
There is exactly one significant gap, and it's pinned to a known fix date.
TypeScript 7.0 does not expose a programmatic API. Any tool that imports from the typescript package to manipulate the compiler programmatically — chief among them typescript-eslint, ts-jest, ts-node, and many type-aware editor plugins — cannot run on TypeScript 7 until the API lands in TypeScript 7.1.
Microsoft shipped a side-by-side escape hatch so you can run both at once. Install the compatibility package @typescript/typescript6 alongside the main package, and you get both binaries on your PATH:
npm install -D typescript@npm:@typescript/typescript6
That setup gives you tsc (TypeScript 7, for builds) and tsc6 (TypeScript 6, for the API-consuming tools that have not updated yet). Most teams should plan to live in this split state until TypeScript 7.1 ships the new API and the tool ecosystem catches up.
What this means for you
TypeScript is now the most-used language on GitHub — it overtook Python and JavaScript in August 2025 with 2.63 million monthly contributors, a 66% year-over-year jump, in what GitHub's own Octoverse 2025 report called "the most significant language shift in more than a decade." That makes the compiler a piece of infrastructure, not a language nicety, and TypeScript 7 finally gives that infrastructure performance that scales with the size of your codebase.
- For solo builders and small teams: you can install TS 7 today for your own builds and get the editor win immediately. The
tsc6compatibility package means any plugin that has not upgraded yet keeps working. Pair it with a faster runtime layer like the all-in-one Node.js toolkit Nub and your whole TypeScript toolchain suddenly feels like Bun — without switching runtimes. The largest sublime-time win lands on thousands-file projects that previously took multiple seconds to respond in the editor. - For engineering leads running CI at scale: the most measurable win is CI time and merge-queue throughput. Slack publicly reported type-checking dropping from ~7.5 minutes to ~1.25 minutes and a 40% reduction in merge-queue time; Microsoft News Services reported saving 400 developer-hours per month waiting for CI builds. Look honestly at whether this changes the conversation beyond TS — AI coding tools are not making developers faster on their own, but removing the 1+ minute per-keystroke type-check latency compounds with every other productivity lever you have. Even factoring for codebase differences, those are not edge cases — they reflect the multiplier you get when a 10–12x faster compiler is on a critical path.
- For teams shipping AI-generated TypeScript: the 80% drop in language-server failures and 60% drop in crashes mean your validator loop (the squiggles that catch AI-written code mistakes) actually runs instead of stalling. That compounds with the broader finding that static types catch ~94% of LLM compilation errors — TS 7 means the safety net fires on time. Pair it with engineering safe AI agent loops for production codebases: when the compiler validates an agent's diff in milliseconds, you can afford tighter agent autonomy bounds and still ship safe code. The same pattern reshapes the developer skills gap — engineers who understand when to lean on a fast compiler (instead of a slow one they had to mentally emulate) keep compounding their output.
The decision is essentially: upgrade your own builds now; let the plugin ecosystem catch up before you delete TypeScript 6. If your codebase is large, the win is not subtle — it changes whether it is realistic to type-check the whole repo on every keystroke. And if you've been eyeing the wider TypeScript-to-native story (running TS outside Node, shipping binaries, lower cold-start), pair this release with our guide to compiling TypeScript to native machine code — TS 7's Go toolchain is the upstream shift that makes that downstream story practical.
FAQ
Q: Is TypeScript 7 free?
A: Yes. TypeScript is MIT-licensed open source and installs free via npm install -D typescript. There is no paid tier — the only costs are your existing CI compute and your editor's CPU. The Go rewrite lowers the CI cost side of that equation rather than adding a new one.
Q: Does TypeScript 7 change the language — new syntax, new rules? A: No. TypeScript 7 is a port of the existing compiler, not a feature release. Its goal is to produce identical type-checking output as TypeScript 6, only faster. There are no new language features gated behind the version bump. If your codebase builds on 6, it should build on 7 with the same types. (Language-level features land in their own versioned cycles — the 7.0 release is purely a performance and tooling jump.)
Q: How much faster is TypeScript 7 on a typical codebase?
A: Microsoft's published benchmarks show 8x–12x faster full builds across project sizes from ~12k-line repos like tldraw up to 1.3M-line VS Code. Raising --checkers from the default 4 to 8 pushes the largest codebases up to ~16.7x on suitable multi-core hardware. Editor first-error response time on the VS Code codebase fell from ~17.5s to under 1.3s.
Q: Will my ESLint, ts-jest, or ts-node setup break?
A: Not if you keep the side-by-side install. TypeScript 7.0 ships without a programmatic API, so packages that import TypeScript's internals (the biggest being typescript-eslint, ts-jest, and ts-node) cannot use 7 directly yet — they wait for TS 7.1 to expose the new API. The official workaround is the @typescript/typescript6 compatibility package, which provides a tsc6 binary so those tools keep working while you build with tsc (TS 7) in parallel.
Q: Why Go and not Rust, C#, or another compiled language? A: Microsoft's design notes explain it: Go's portable runtime, mature garbage-collected memory model, and goroutine-based concurrency with shared-memory were the right fit for a large, parallel compiler pipeline. The choice was engineering-fit, not political — Go's concurrency model is what unlocked the shared-memory multithreading that accounts for roughly half the speedup.
Q: Do I need a multi-core machine to benefit?
A: You benefit on any modern machine because half the speedup is just from native code (Go compiles to the CPU, no JIT overhead). But the more cores you have, the more you get out of --checkers and --builders. A 14-core laptop can push --checkers 12 and cut a 45s build to under 4s; a 4-core machine still sees the native-code speedup, just with a smaller concurrency dividend.
Discussion
0 comments