TypeScript 7 Native Go Build Delivers Up to 12× Faster Compilation

TypeScript 7.0 was released on July 8 (local time) and represents the most radical architectural change in the language’s history. The compiler—including the type checker, code generator, and language server—has been completely rewritten in Go. In real‑world codebases the native version achieves an 8‑12× build‑time improvement, with some projects seeing even larger gains.

Build performance data : The VS Code codebase (a massive TypeScript project) compiled in 125.7 s with the old compiler and only 10.6 s with the Go version—a 11.9× speedup. Sentry’s build time dropped from 139.8 s to 15.7 s. Across all tested repositories memory consumption fell by 6 %‑26 %. Editor‑side latency also improved dramatically; the time to surface the first error in VS Code fell from 17.5 s to under 1.3 s (≈13× faster), fundamentally changing the developer experience for large TypeScript projects.

Why Go instead of Rust? The TypeScript team initially considered Rust, but Go was chosen because the existing compiler code heavily uses graph structures, garbage collection, and many cyclic data structures. Rust’s ownership model would forbid such cycles without complex work‑arounds, requiring a multi‑year redesign of the AST. Ryan Cavanaugh (TypeScript lead) and a Hacker News commenter both emphasized that Go’s 1:1 code‑base mapping and fast development speed made it a practical choice, even though Rust can be up to 20 % faster in raw execution.

Production validation : Before public release the Go implementation ran for over a year on millions of lines of code at companies such as Bloomberg, Figma, Google, Slack, Notion, and Vercel, proving its stability at scale.

Upgrade considerations : Prior to 7.0 the compiler was written in TypeScript and ran on JavaScript, limiting multi‑core utilization. The Go rewrite brings native performance, shared memory, and multithreading. Whether to upgrade depends on the frameworks and tools a project uses. If a project builds TypeScript directly and does not rely on deep integration with the compiler’s programming API, TypeScript 7.0 is a stable production upgrade. The installation command remains unchanged: npm install -D typescript@7 Followed by the usual npx tsc invocation.

Compatibility package : Because some ecosystems (e.g., Vue, Svelte, Astro, MDX) still embed the compiler and the TS 7 API is not yet stable, Microsoft provides a compatibility package @typescript/typescript6 that supplies the TS 6 API and a separate tsc6 command. Projects can install both versions side‑by‑side:

{
  "devDependencies": {
    "@typescript/native": "npm:typescript@^7.0.2",
    "typescript": "npm:@typescript/typescript6@^6.0.2"
  }
}

Tools that import the peer dependency will continue using TS 6, while the tsc command can be pointed at the native TS 7 compiler.

Editor support : Dedicated VS Code extensions for TypeScript 7 are already available, and upcoming VS Code releases will auto‑enable the new compiler. Other editors that implement the Language Server Protocol (LSP) will automatically benefit from the multithreaded improvements because the TS 7 language server now follows the LSP standard.

Watch mode redesign : The new --watch mode is a complete rewrite in Go, replacing the previous polling‑based implementation that was costly for projects with large node_modules trees.

New parallel flags (added in 7.0): --checkers – sets the number of type‑checker worker threads (default 4). --builders – controls parallel project reference builds. --build – enables parallel reference builds. --singleThreaded – disables all parallelism, useful for debugging or low‑resource CI runners.

Microsoft cautions against overly aggressive combinations (e.g., --checkers 4 --builders 4) because the runtime caps at 16 concurrent checkers.

Future outlook : Microsoft states that TS 7.0 is not the final state of the Go migration. TypeScript 7.1, expected around October 2026, will focus on a stable programmatic API to close remaining ecosystem gaps, enabling tools like Volar and other framework template type checkers to adopt the native compiler. Beyond API stability, the team will return to new language features, ergonomic improvements, and further performance optimizations in the native runtime.