I’m porting tsc to Go

I’m porting the TypeScript Type Checker tsc to Go, and not Rust. As the creator of SWC, an extensible Rust platform, this might sound strange. Let me explain.

Why port tsc?

As TypeScript continues to rise in adoption, large projects are facing a dilemma: type checking is one of the slowest parts of their workflow. Developers want type safety without the tradeoff of slower iteration cycles.

The TypeScript Compiler, or tsc, checks the validity of your types and compiles your code to JavaScript. The more code you have, the longer it takes to compile. On medium-to-large-sized TypeScript projects, this compilation is extremely slow. While developers can replace the transpilation part of their workflow with SWC, type checking has still been a bottleneck.

What is a type checker?

A type checker validates your program before execution and ensures you've used correct values for function calls and variable assignments. To prevent you from specifying types everywhere, it also infers variable types whenever possible. Type checking helps you develop with confidence, prevent mistakes, and enables smoother refactoring of large codebases.

Why not Rust?

I tried to rewrite tsc in Rust. It started as a side project and was a lot of fun. I started recreating the type checking logic without looking at the tsc source code.

Early tests of my Rust rewrite showed 62x faster type checking than tsc. To measure the compile-time between SWC and tsc, I used the conformance test suite from the official TypeScript compiler. Here were the results (using 8 threads):

• tsc: 133.2 seconds
• Rust rewrite: 2.13 seconds (62x faster)

Eventually, I realized that rewriting a massive project such as tsc would be extremely difficult to continue. But the performance gains were exciting. This led me to try another route: porting instead of a complete rewrite. So, I started looking at the TypeScript source code.

tsc uses a lot of shared mutability and many parts depend on garbage collection. Even though I’m an advocate and believer in Rust, it doesn’t feel like the right tool for the job here. Using Rust required me to use unsafe too much for this specific project.

tsc depends on shared mutability and has a cyclical mutable reference. Rust is designed to prevent this behavior. Having two references to the same data (shared mutability) is undefined behavior in Rust.

Your language choice should be determined by the task, and not by preference. So even though I love Rust, I started experimenting with Go and Zig for this project and chose to use Go.

Will it be open-source?

Vercel is sponsoring and funding the work to port tsc to Go. We’re planning to open-source this work in the future. I’ll also be creating a bridge to use this new version of tsc with SWC.

With type checking support, SWC is working to improve the performance of your entire JavaScript / TypeScript toolchain:

• ✅ Transpilation (replacing Babel)
• 🚧 Type Checking (replacing tsc)
• 🚧 Minification (replacing Terser)
• 🚧 Bundling (replacing webpack)

For project updates, follow me on Twitter.