TypeScript 7.0: The Go-Powered Compiler Making Builds 10x Faster

TypeScript 7.0 is the most consequential release in the language's history — not because of new syntax, but because of what's underneath. The entire compiler has been rewritten in Go, and the result is builds that are up to 10x faster, type-checking that finishes in a fraction of the time, and memory consumption that drops by nearly 3x.

If you work on any TypeScript codebase of meaningful size, this upgrade will change how your CI pipeline feels — and how quickly your editor responds.

What Is Project Corsa?

Project Corsa is Microsoft's internal codename for the Go-native port of the TypeScript compiler. The goal wasn't to introduce new language features; it was to break through the fundamental performance ceiling imposed by running the compiler as a Node.js process.

The JavaScript-based tsc was architected for correctness and portability, but it hit hard walls: a single-threaded event loop, V8 garbage-collection pauses, and memory limits that made large monorepos painful. A million-line codebase compiling in 89 seconds was acceptable in 2018; by 2026, developers expect near-instant feedback.

Microsoft evaluated Rust, C#, and Go before choosing Go. The reasons were practical:

• The TypeScript compiler's functional, recursive architecture maps cleanly onto Go idioms
• Go's garbage collector handles the workload without manual memory management
• esbuild had already proven that Go-based JavaScript tooling could achieve dramatic speedups
• Porting the codebase methodically (rather than rewriting from scratch) preserved correctness

The type-checking logic in TypeScript 7 is structurally identical to TypeScript 6 — only the execution environment changed.

Benchmarks: The Numbers Are Real

Microsoft tested the new compiler against major open-source codebases. The results are consistent:

Beyond compile time:

• Type checking: up to 30x faster on medium-to-large projects
• Memory usage: 2.9x more efficient (68 MB → 24 MB on benchmarked projects)
• Editor startup: VS Code language service drops from 9.6s to 1.2s

Smaller codebases (under 50k lines) see more modest 2–5x gains — Go's parallelism pays dividends at scale. But even on a 10,000-line project, cold-start time drops noticeably.

Architecture Changes Under the Hood

The new compiler (tsgo) compiles to a native binary for each platform — Windows, macOS, Linux, and ARM — meaning there is no Node.js warmup, no V8 JIT compilation cost, and no JavaScript heap pressure.

Go's goroutines replace the single-threaded JavaScript event loop. TypeScript 7 uses shared-memory parallelism to type-check multiple files concurrently. The default is 4 checker workers, configurable via --checkers={count} for machines with more cores.

For monorepo setups — Yarn Workspaces, Lerna, Nx — this is transformative. Projects that previously had to wait for serial project-reference builds can now run multiple packages in parallel without extra orchestration tooling.

What Changes for Your Code

TypeScript 7 adopts all of TypeScript 6's breaking changes as hard errors. If you're migrating from TypeScript 5 or earlier, the jump is significant:

Strict mode is now the default. Previously you had to opt in; with TS7, strict mode is on unless explicitly disabled.

ES5 target is removed. The minimum output target is ES2021. If your project targets legacy browsers and relied on "target": "es5", you'll need a separate transpilation step (esbuild or Babel downstream).

AMD and UMD module formats are gone. These have been deprecated for years; TS7 removes them entirely.

ES2015 module resolution remains supported, but node10 (the legacy Node module resolution) is deprecated in favor of node16 or bundler.

Testing tsgo Today

TypeScript 7 is in beta as of April 2026, with GA expected in Q2 2026. You can install the preview compiler today:

npm install -D @typescript/native-preview

Run it alongside your existing tsconfig.json:

npx tsgo -p . --extendedDiagnostics

Note: tsgo does not yet support --init. Use tsc --init to generate your tsconfig, then switch to tsgo for compilation and type-checking.

# Quick version check
npx tsgo -v
 
# Type-check only (no emit) — useful for CI
npx tsgo -p . --noEmit

For production builds, continue using TypeScript 6 until the stable GA release. The recommended workflow is:

1. Run tsgo --noEmit in CI to validate types with 10x speed
2. Keep tsc (TS6) for the emit step until TS7 GA

What's Not Ready Yet

Be aware of these current limitations before switching fully:

• JavaScript emit is incomplete. The Go compiler handles type-checking well, but the code generation pipeline is still being finalized.
• Decorators are not yet supported. Projects using @Injectable, @Component, or similar patterns (NestJS, Angular) cannot fully migrate yet.
• TSServer → LSP migration. TypeScript 7 moves from the custom TSServer protocol to the Language Server Protocol (LSP). Most editors will handle this transparently, but custom IDE integrations may need updates.

The Migration Path

The cleanest upgrade path is staged:

Step 1 — Upgrade to TypeScript 6 first. TypeScript 6 (released March 23, 2026) is a bridge release. It enables strict mode warnings, flags ES5 target usage, and warns on AMD/UMD. Use it to surface and fix all breaking changes before TS7.

Step 2 — Install the native preview. Add @typescript/native-preview as a dev dependency and run tsgo --noEmit on your codebase to see if there are any remaining incompatibilities.

Step 3 — Migrate CI to tsgo for type-checking. Replace your tsc --noEmit CI step with tsgo --noEmit. Your build times drop immediately; production emit still uses TS6.

Step 4 — Await GA for full migration. Once TypeScript 7.0 stable is released (expected Q2 2026), update your entire toolchain.

For large enterprise codebases, budget 1–2 sprint cycles for the TypeScript 5 → 6 → 7 path. Most of the work is in the TS5 → TS6 step (fixing strict mode and module resolution changes).

Is It Time to Switch?

For type-checking validation today, yes — install the preview and put tsgo --noEmit in your CI. The speed improvement is real and immediate, with no code changes required for most projects.

For full production use, wait for the GA release. The JS emit pipeline and decorator support are the remaining blockers for most applications.

TypeScript 7.0 doesn't add new syntax or type system features — it accelerates the entire developer experience. Faster CI means faster iteration. Faster type-checking in the editor means fewer context switches. For teams working on large TypeScript codebases, the upgrade is not optional; it's overdue.

The Go rewrite is a reminder that sometimes the best engineering decision isn't a new feature — it's rebuilding the foundation at a different order of magnitude.