TypeScript 7 RC unveiled with compiler rewritten in Go for much faster faster performance

TypeScript 7 Compiler Rewritten in Go: much faster Faster Builds and Editor Performance

The TypeScript 7 release candidate is out, and it’s more than your usual “yet more syntax.” Microsoft has ported the entire compiler to Go, promising TypeScript developers something we almost never get: serious real-world speed. The team claims much faster faster builds and much snappier editor feedback—the kind that makes large projects feel light again. This rewrite isn’t just technical theater; it’s changing the game for anyone shipping TypeScript at scale.

If you’re wondering whether to bet early on TypeScript 7 or how the Go rewrite changes your workflows, here’s why these speed gains actually stick, how to use the new compiler today, and what it means for the future of TypeScript development.

What is the TypeScript 7 compiler rewritten in Go?

Until this release, the TypeScript compiler was itself written in TypeScript—compiling down to JavaScript, then running as a Node.js process. This approach worked but imposed hard caps: running inside a JS VM meant fundamentally serialized execution, thread limits, and a reliance on V8’s garbage collector.

TypeScript 7 isn’t so much a “rewrite” as a port. Microsoft took the live codebase—the type checker, inference logic, and emit path developers rely on—and moved it into Go. They did not start over. They transcribed each piece methodically to preserve the behavior you already depend on from TypeScript 6. This means the new compiler is structurally identical where it matters: no subtle logic changes, no new type system bugs, no surprises in what passes or fails type-checking.

For developers, this is nearly invisible at the source level. Write TypeScript as before. Existing config files mostly work—except deprecated flags, which now throw hard errors. What’s visible is only the speed, and, for the first time in years, the engine under the hood matters.

The TypeScript 7 Go-based compiler is open source under Apache 2.0, drawing over 25,000 GitHub stars. Around 85% of the repo is Go code; the rest handles interop, tests, and compatibility shims. This is not a side project—it’s the new foundation for all things TypeScript.

Why is the Go-based compiler so much faster?

It’s not magic—it's physics. Go compiles straight to native machine code. There’s no JavaScript interpreter lying between your CPU and your build graph. More importantly, Go’s concurrency primitives and shared memory model allow the new TypeScript compiler to fully saturate your machine’s cores—parallelizing the type-checking and code emission steps that previously bottlenecked in the single-threaded JS runtime.

Microsoft reports build times that are around much faster faster than the previous major release. These aren’t just internal benchmarks. Major users—Figma, Bloomberg, Vercel, Notion, and Slack—have been trialing pre-release builds for a year, and report similar figures: cold starts that drop from minutes to seconds, full project builds nearly an order of magnitude faster.

This re-architecture enables not just speed, but predictability. With Node, build times were subject to random slowdowns from garbage collection pauses. Go’s memory management makes compilation times more stable, especially at scale.

Everything that used to be CPU-constrained is now GPU-quick by comparison. The TypeScript 7 compiler spins up threads for type resolution, module traversal, and code emission in parallel. The previous JavaScript implementation, on Node, couldn’t do this without gnarly worker/thread orchestration that introduced its own costs.

Summary table:

Takeaway: The Go rewrite enables native performance, predictable scaling with cores, and sheds the memory/GC tax. For any non-trivial codebase, this is a real step function, not a rounding error.

How does this speed improvement affect your daily development?

The acceleration isn’t limited to CI or the command line. It’s just as visible in your editor.

• Faster builds: Running tsc to build a project is no longer the IO-bound, multi-minute affair. Even for big monorepos or legacy projects, expect the kind of speed that changes whether you consider TypeScript “sluggish.”

  # Old (TypeScript 6, large project)
  tsc --build
  # ~120 seconds
  
  # New (TypeScript 7 RC, Go engine)
  tsc --build
  # ~12 seconds (per Microsoft and early Figma/Notion/Vercel reports)

• Snappier Language Server Protocol (LSP) interactions: The compiler powers your editor’s LSP backend, which handles completions, type hovers, and inline errors. With the Go port, your IDE’s responsiveness improves—real-time linting and autocomplete suggestions come without the “wait for Node to catch up” lag.

• Scale-friendly for large teams/projects: Previous large-graph recompiles created artificial pain for big codebases. Not with 7. The difference is most dramatic for users with large workspaces and many type dependencies—editor navigation, type info, and error reporting no longer stall under load.

• Feedback from early adopters: Per Microsoft (and confirmed by pilots at Bloomberg and Vercel), these UX gains are felt most in "day-long" editor sessions on sprawling projects. You’ll feel less friction with every keystroke.

Takeaway: If you work in or maintain a considerable TypeScript codebase, the Go compiler is the closest thing to an instant upgrade for productivity that the language ecosystem has shipped yet.

How to use the TypeScript 7 compiler rewritten in Go today

Trying the TypeScript 7 RC compiler isn’t hand-wavy futureware; the public repo is live, and the install flow is painless.

1. Install TypeScript 6 first: TypeScript 7 enforces new hard errors for deprecated config. Upgrade to v6 first; resolve all warnings.

   npm install typescript@6 --save-dev
   npx tsc --project tsconfig.json
   # clear all deprecated options, correct flagged configs

   Key deprecated config flags that will now break builds in 7:

   • target: es5
   • moduleResolution: node
   • baseUrl
   • module: amd/umd/systemjs

   Defaults have also hardened (strict: true, module: esnext).

2. Upgrade to TypeScript 7 RC:

   npm install typescript@7.0.0-rc --save-dev

   Or, for direct GitHub access (if you want to pull the latest Go compiler builds), clone and build from the source repository:

   git clone 
   cd TypeScript
   make build
   # Uses Go toolchain (see repo README for any Go version constraints)

3. Use the Go-native tsc binary: The standard tsc CLI now invokes the Go-native backend by default.

   npx tsc --project tsconfig.json

   If you want to verify which runtime you're hitting, check the binary:

   tsc --version
   # outputs TypeScript 7.0.x (Go)

4. Editor integration: Most modern editors (VS Code, WebStorm) look for a local version first. Once upgraded, restart your editor to pick up the Go-powered LSP.

5. License and community:

   • Repo: Apache 2.0 licensed.
   • Community: Over 25,000 stars, open issues, and PRs welcome.
   • The move to Go enables more contributors with Go experience, while TypeScript/JS-native devs can focus on language and tooling.

What does this mean for the future of TypeScript development?

This is a foundational shift for TypeScript, and not just in superficial speed. The decision to port to Go enables several doors:

• Further speed potential: Now that the performance ceiling is native code and parallelism, expect the core team (and the broader OSS community) to drive even bigger optimizations in future releases, from smarter compile caches to experimental incremental compilers written for multi-core workloads.
• Broader tooling integrations: IDEs, continuous integration pipelines, and new TypeScript-adjacent tools can count on consistent and predictable speed. No more fighting the randomness of Node/GC pauses. Expect to see faster, CI-native plugins and even entirely new classes of language tooling built on the Go core.
• Expanded contributor base: Go is a widely taught—and inviting—systems language. This may open TypeScript’s internals to a new wave of contributors, unblocking core compiler contributions that were previously limited to experts in JS self-hosting.
• TypeScript’s industry moment: Large shops betting on TypeScript (think Bloomberg, Figma, Vercel, Notion, Slack) provided real production feedback, confirming this wasn’t a lab experiment. The Go port solidifies TypeScript as a principal ecosystem for serious, large-scale development.

Takeaway: The Go rewrite doesn’t just dump baggage; it sets the floor for platform-level speed and opens the architecture for serious, systems-grade improvements in TypeScript’s future.

Closing: TypeScript finally grows up

For years, TypeScript felt like the language that tried to match JavaScript’s flexibility but paid for it in every long build and sluggish code navigation. TypeScript 7, with its compiler now in Go, is the real break. Fast builds and near-instant editor feedback aren’t a footnote—this is how scale-obsessed teams actually move fast. If you haven’t upgraded, now is the time. The Go-native core is only the start of TypeScript’s next phase—built for performance, portability, and the kind of contributor power modern ecosystems need. The speed is real. The future-proofing is real. And you can try it today.