By ByteBot
Microsoft shipped TypeScript 7.0 Beta on April 21, and the message is hard to ignore: the compiler you’ve been using is now the slow path. The new tsgo — a complete port of TypeScript’s compiler to Go — builds VS Code’s 1.5-million-line codebase in 7.5 seconds. The old tsc takes 78. You can run the beta today.
The Numbers, and Why They Matter
TypeScript 7.0 (Project Corsa) is often 10x faster than TypeScript 6.0 across real-world codebases. That’s not a cherry-picked micro-benchmark — it’s the figure Microsoft measured on their own VS Code repository, then independently verified by developers who ran it against their own projects.
| Scenario | tsc 6.0 | tsgo 7.0 beta | Speedup |
|---|---|---|---|
| VS Code (1.5M lines) | 78.0s | 7.5s | 10.4x |
| Type check only | 1.053s | 0.299s | 3.5x |
| Memory usage | baseline | 2.9x less | — |
CI pipelines that spend 2-3 minutes on tsc --noEmit will drop to 15-30 seconds. For large monorepos, this is the kind of change that affects how frequently developers actually run type checks — and whether they skip them under deadline pressure.
The type-checking semantics are identical to TypeScript 6.0. If your code passes tsc today, it will pass tsgo. No new false positives. No behavior changes. Just speed.
How to Try It Right Now
The beta ships as @typescript/native-preview. Installation is one line:
npm install -D @typescript/native-preview
# Type-check your project
npx tsgo --noEmit
# Full build
npx tsgo --buildIf you’re on VS Code, install the TypeScript (Native Preview) extension from the VS Marketplace. It runs the native language server — same auto-imports, inlay hints, and go-to-definition, but noticeably snappier on large projects. VS 2026 Insiders already has it enabled by default.
Microsoft tested pre-release builds at Bloomberg, Canva, Figma, Google, Slack, and Vercel. The feedback was consistent: the speedup is real, and the editing experience on large codebases feels qualitatively different — not just faster on a timer, but more fluid to actually work with.
Why Go, Not Rust or C#
Anders Hejlsberg’s team spent serious time evaluating alternatives before landing on Go. The choice reveals something interesting about TypeScript’s codebase that outsiders often underestimate.
TypeScript’s compiler is written in a heavily functional style: closures, recursive data structures, and pattern matching on discriminated unions everywhere. Rust’s ownership model fights that pattern constantly. A Rust port would have taken 3-5x longer and required rethinking the architecture from scratch — at which point you’re not porting, you’re rewriting, and you’re taking on the risk of behavioral incompatibilities.
C# was prototyped. It didn’t make the cut either. Go matched TypeScript’s existing memory management patterns and gave the team something JavaScript can never provide: goroutines. Parsing and emit are “embarrassingly parallel” — each file can be processed independently. Old tsc was bottlenecked on Node.js’s single-threaded runtime by design. tsgo spins up goroutines and processes files concurrently. That’s where the 10x comes from.
What Breaks (Read This Before Migrating)
The beta is genuinely stable — Microsoft says it’s “ready to be put to the test in your daily workflows.” But it has real limitations that matter depending on what your project does:
- Custom transformer plugins — The old Strada API is not yet supported. If your build uses compiler transforms (NestJS decorators, typeorm, some emotion setups), this is a hard blocker for now.
- Decorators with older targets — Downlevel decorator compilation is not done yet. The beta handles ES2021+ targets only; ES2015 support is planned but not shipped.
- JSDoc patterns —
@enumand@constructorare no longer recognized for JS checking codebases. Pure TypeScript projects are unaffected. - Vue language-tools — Active migration is underway (issue #5381), but it’s not complete. Vue devs should hold off on the editor extension for now.
One common misconception: ts-node, esbuild, SWC, and Babel are completely unaffected by tsgo. Those tools have their own TypeScript transpilation pipelines and don’t use tsc for emit. If you use Vite or Bun, you’re already in the clear — adopt tsgo for the type-check step and get the speedup there.
The Bigger Picture
There’s an irony worth sitting with. TypeScript’s pitch was always “JavaScript that scales.” But the compiler itself didn’t scale — it slowed progressively on large codebases, until the ecosystem invented SWC and esbuild specifically to route around it. Microsoft just had to rewrite their own tool in a compiled language to match what the community built years ago out of frustration with tsc’s performance.
TypeScript 6.0 remains the production baseline until the stable release — projected for late June or early July 2026. The beta is production-ready for type-checking on most projects without custom transforms. For everyone else, the RC is weeks away.
If your CI type-check step is over 10 seconds, there’s no reason not to be testing tsgo today. The official announcement covers the full feature set, and the typescript-go repository on GitHub tracks known limitations and migration progress in real time. For a hands-on installation walkthrough, this DEV Community guide is the most practical starting point.
