Microsoft just dropped something I’ve been quietly hoping for: a native port of the TypeScript compiler that benchmarks at roughly 10x faster than the current JavaScript-based implementation.
If you’ve ever watched tsc churn through a large codebase and thought “this feels wrong” — yeah, same. The irony of TypeScript being compiled by a TypeScript (well, JavaScript) runtime has always been a bit uncomfortable for performance-critical workflows.
What’s Actually Happening
The TypeScript team is porting the compiler to native code. Early reports point to Go as the implementation language, which is an interesting choice — fast compilation, good concurrency primitives, and a garbage collector that doesn’t hurt as much as you’d expect for this kind of workload.
The result is a tsc equivalent that can handle the same type checking and emit work in a fraction of the time. For large monorepos or projects with hundreds of files, that’s not a marginal improvement — it changes the feedback loop entirely.
Why This Matters More Than Benchmarks
A 10x speedup sounds impressive in isolation, but the real unlock is at scale. If you’re working on a small project, TypeScript is already fast enough. Where it starts to hurt is:
- Large monorepos with thousands of source files
- CI pipelines where type checking is a blocking step
- Editor integrations where the language server struggles to keep up with rapid edits
I’ve personally hit that wall working on larger Node projects. The language server starts lagging, incremental builds feel less incremental, and you start reaching for // @ts-ignore just to keep moving. A native compiler won’t fix bad types, but it removes the friction that makes you stop caring about them.
The Systems Programming Angle
Having dabbled in Rust and Go myself, I find the implementation choice fascinating. The TypeScript compiler is a complex piece of software — recursive type resolution, declaration merging, structural compatibility checks. Porting that faithfully to a statically typed systems language while maintaining correctness is genuinely hard work.
This isn’t a rewrite-for-fun project. It’s a deliberate investment by the TypeScript team to unblock a real scaling problem. That’s the kind of engineering decision that ages well.
What To Do Right Now
The native port is in preview. If you want to try it:
npm install -D @typescript/native-previewRun it against your existing project and see how it compares. The team is collecting feedback, and early testing on real codebases is exactly what they need.
Keep in mind this is preview software — don’t drop it into production CI yet, but absolutely benchmark it. If you find a correctness issue or a case where it diverges from standard tsc, that’s valuable signal worth reporting.
The Bottom Line
This is one of those announcements that doesn’t require much hedging. Faster TypeScript, especially at the scale where it actually hurts today, is unambiguously good. The ecosystem already benefits from tools like esbuild and swc doing transpilation at native speed — having type checking join that tier closes the last big performance gap.
Go try the preview. Report what breaks. This one’s worth paying attention to.