TypeScript 7 (tsgo): 10x Faster Compiler in 2026

[Alex]: Welcome back to the Nerd Level Tech AI Cast, the only podcast where our build times are still longer than our intros—though maybe not for long!

[Jamie]: Speak for yourself, Alex. I’m still waiting on that “make coffee while you build” feature in my IDE. Hey everyone, I’m Jamie, and today we’re talking about something that’s got the entire TypeScript community buzzing: the TypeScript 7 compiler, codenamed “Corsa,” and its shiny new Go-powered engine, tsgo!

[Alex]: That’s right. TypeScript 7 is not just another version bump—it’s a full-on native port of the compiler from JavaScript to Go. And the headline is big: Microsoft claims it’s about ten times faster than the old TypeScript 6 builds.

[Jamie]: Ten times! I mean, if my builds finish before I can open Twitter, what am I supposed to do with my hands? [PAUSE] Okay, but, Alex, let’s back up—what actually changed here? Why is TypeScript suddenly written in Go?

[Alex]: Great question. So, for years, TypeScript’s compiler—tsc—was itself written in TypeScript and ran as JavaScript on Node.js, which means it was basically living inside the V8 engine and limited to single-threaded execution. Microsoft spent about a year porting it to Go, not rewriting it, just translating it line by line, so the type-checking logic is identical to TypeScript 6.0. The difference is, Go gives you that sweet, sweet native code speed and real parallelism.

[Jamie]: So, my .ts files still compile the same, just… turbo-charged? [PAUSE] And, uh, for the folks at home—why Go? I know Rust fans are probably clutching their Cargo.tomls right now.

[Alex]: Oh, the Rust vs. Go debate was *epic* on Hacker News. But here’s the deal: TypeScript’s compiler relies on a lot of shared, pointer-heavy data structures. Go is great for that—it’s got a garbage collector, supports cyclic data, and makes concurrency easy with goroutines. Rust’s borrow checker, while awesome for safety, would have meant basically redesigning the whole compiler. So, Go was the pragmatic choice: fast, low-risk, and lets Microsoft port the codebase without starting from scratch.

[Jamie]: So it was less “which language is coolest” and more “which language won’t make us rewrite a decade of code and cry”?

[Alex]: Exactly! And as much as I love Rust, sometimes you just want to move fast and not break things—unless those things are your build times.

[Jamie]: Speaking of build times—let’s talk numbers. How much faster *are* we talking here?

[Alex]: Microsoft benchmarked tsgo on some pretty big codebases. Take VS Code, for example—1.5 million lines of code. With the old JavaScript-based tsc, it took about 78 seconds to type-check. With tsgo? Just 7.5 seconds.

[Jamie]: That’s… wow. That’s like, making breakfast versus making a Pop-Tart.

[Alex]: Or just eating the Pop-Tart raw, no toasting needed! [PAUSE] And it’s not just VS Code. Projects like Playwright, TypeORM, even smaller ones like rxjs—all saw 9x to 13x speedups. Plus, editor project-load times dropped from about 10 seconds to just over one second. And memory usage? Cut in half.

[Jamie]: Okay, but you know what I’m gonna ask—how do we actually try this out? Is it out now, or do we have to wait for the stable release?

[Alex]: You can absolutely try it now. The public beta dropped back in April. Just run `npm install -D typescriptnative-previewbeta`, and use the `tsgo` command instead of `tsc`. You can run them side by side, so you don’t have to nuke your existing toolchain. Handy for those of us who like to live dangerously, but not *that* dangerously.

[Jamie]: [chuckles] So, just swap `tsc` for `tsgo`, and you’re off to the races! [PAUSE] Any editor magic needed?

[Alex]: Yep, there’s a TypeScript Native Preview extension for VS Code. It’s built on the Language Server Protocol, which means it should play nicely with other editors too. The team is really aligning TypeScript with how other languages plug into editors now.

[Jamie]: Alright, let’s get to the spicy stuff. Any breaking changes or “gotchas” if I upgrade my project?

[Alex]: Oh, there are some changes you *really* want to check before upgrading. For starters, `strict` mode is now on by default. So if you were living life on the edge with loose typing, it’s time to get strict or get errors.

[Jamie]: Like eating kale instead of chips—good for you, but not always what you want. What else?

[Alex]: Modules now default to `esnext`, and a bunch of old config flags are gone—like `target: es5`, `baseUrl`, and `moduleResolution: node`. Those are now hard errors. Deprecated flags like `amd`, `umd`, and `system` modules are no longer supported. If you’ve got legacy configs, you’ll want to clean those up. Also, if your codebase is heavy on JavaScript with JSDoc, some Closure-style annotations are no longer specially recognized, so definitely test those.

[Jamie]: So, the “just works” upgrade… isn’t always “just works.” Any tips for teams trying to upgrade but not break everything?

[Alex]: Microsoft actually recommends running both compilers side by side for a while. There’s even a compatibility package called `typescriptnpm:typescripttypescript6`, so you can alias your old setup and not break tools like `typescript-eslint`.

[Jamie]: Nice! And what’s this about parallelism controls? I saw something about “checkers” and “builders”—is this like Pokémon, gotta catch ‘em all?

[Alex]: [laughs] Not quite, but close. With tsgo, you can now control how many type-checking workers run in parallel using the `--checkers` flag. The default is 4. If you’ve got a beefy machine, you can crank it up, but more workers mean more memory. There’s also `--builders` for project-reference builders—especially handy for monorepos. And if you want to keep things old school, there’s a `--singleThreaded` flag for debugging or performance comparisons.

[Jamie]: But if you set too many checkers and builders, can you break your CI runner?

[Alex]: Yeah, you might end up with a wall of “out of memory” errors. Microsoft actually warns that `--checkers 4 --builders 4` can spawn up to 16 processes, which “may be excessive.” So, you know, don’t go full “YOLO” in production.

[Jamie]: [PAUSE] Last big question—when’s the stable release actually coming?

[Alex]: Microsoft’s plan was to ship stable TypeScript 7 by late June 2026. As of right now, it’s still in beta, but it’s already running on massive codebases at places like Slack, Google, and Notion. The beta label is pretty conservative—they say you can probably start using it for real work today.

[Jamie]: So, it’s not vaporware, just super cautious branding. [PAUSE] Alright, Alex, rapid-fire: should people upgrade now or wait?

[Alex]: If your codebase is already TypeScript 6 clean and you’re not dependent on the compiler API, go for it. If you’re using a lot of deprecated flags or custom tools, maybe hold off until 7.1 lands with the stable API. But for speed demons? Now’s your time.

[Jamie]: And remember folks, with great speed comes… probably, a lot more time to drink coffee. Or, you know, actually write code.

[Alex]: Or, if you’re like me, just stare at your terminal in disbelief that your build is already done. [PAUSE] That’s all for today’s episode of the Nerd Level Tech AI Cast. Thanks for tuning in, and remember—keep your types tight and your builds blazing fast.

[Jamie]: If you enjoyed this episode, subscribe, leave us a review, and share it with your favorite TypeScript meme lord. Catch you next time! [Outro music fades out]