If you’re a developer who loves TypeScript—or even just uses it daily—you’ve probably dreamed of faster builds and snappier editors. Well, that dream is becoming reality with TypeScript Project Corsa, a bold new effort from the TypeScript team at Microsoft. Announced on March 11, 2025, this project is all about making TypeScript run 10 times faster by porting it to native code. Yes, you read that right—10x faster!
But what exactly is Project Corsa? Why is it happening, and how will it change your coding life? In this blog, we’ll break it all down in simple terms. From jaw-dropping speed boosts to what it means for your projects, we’ve got you covered. Let’s dive into this exciting update and see why developers everywhere are buzzing about it!
Table of Contents
What Is TypeScript Project Corsa? The Basics
TypeScript Project Corsa—often just called “Corsa”—is the codename for a native port of the TypeScript compiler and tools. Right now, TypeScript runs on JavaScript (via Node.js), which is great but can get sluggish as projects grow huge. Corsa changes that by rewriting TypeScript in Go, a fast, native programming language. The result? A massive speed boost for everything from command-line builds to editor performance.
Here’s the quick scoop:
- Goal: Make TypeScript 10x faster and lighter on memory.
- How: Port the existing code to Go instead of JavaScript.
- When: A preview by mid-2025, with a full release as TypeScript 7.0 by year-end.
- Who: Led by Anders Hejlsberg, TypeScript’s creator and a Microsoft legend (he also designed C#!).
Think of it like upgrading from a bicycle to a sports car—same journey, way faster ride. Announced on the TypeScript blog and demoed in a YouTube video, Corsa is already turning heads in 2025.
Why TypeScript Needs a Speed Boost
Before we dig into Corsa, let’s talk about why this matters. TypeScript is amazing—it adds types to JavaScript, catching errors early and powering slick editor features like auto-complete and refactoring. But as your codebase grows (think millions of lines), things slow down:
- Long Build Times: Running
tsc(the TypeScript compiler) can take minutes on big projects. - Laggy Editors: Opening Visual Studio Code or finding references feels sluggish.
- AI Struggles: Modern AI coding tools need fast access to your whole project, but delays hold them back.
Developers love TypeScript’s safety and smarts, but waiting around isn’t fun. Corsa aims to fix that by making everything lightning-fast, no compromises.
How Much Faster Is Corsa? Real Numbers
The TypeScript team isn’t just promising speed—they’re showing it. They’ve tested Corsa on popular projects, and the results are wild. Here’s a table from their blog, comparing current TypeScript (JavaScript-based) to the native Corsa version:
| Codebase | Size (Lines of Code) | Current (JS) | Native (Corsa) | Speedup |
|---|---|---|---|---|
| VS Code | 1,505,000 | 77.8s | 7.5s | 10.4x |
| Playwright | 356,000 | 11.1s | 1.1s | 10.1x |
| TypeORM | 270,000 | 17.5s | 1.3s | 13.5x |
| date-fns | 104,000 | 6.5s | 0.7s | 9.5x |
| tRPC | 18,000 | 5.5s | 0.6s | 9.1x |
| rxjs (observable) | 2,100 | 1.1s | 0.1s | 11.0x |
What does this mean?
- Big Projects: VS Code’s build drops from over a minute to under 8 seconds.
- Small Projects: Even tiny libraries like rxjs go from 1 second to a blink.
- Average Gain: Around 10x faster across the board.
These tests use tsc for type-checking, and while Corsa isn’t fully finished, it’s already crushing it. Imagine waiting 7 seconds instead of 77—that’s a coffee break you don’t need!
Why Go? The Big Language Choice
Here’s a question popping up everywhere (especially on X): why port TypeScript to Go instead of Rust, C#, or another language? Anders Hejlsberg explains it in the video at the 2:30 mark:
- Fast Compilation: Go builds super quick, perfect for a compiler.
- Simple Concurrency: Go’s design makes parallel tasks (like checking files) easy.
- Single Binaries: Go spits out one executable file—no messy setup.
- Matches TypeScript: Go’s structural typing fits TypeScript’s code like a glove.
Rust was considered (and fans are vocal about it!), but its manual memory management would slow down development. Go’s garbage collection (GC) keeps things smooth without rewriting everything from scratch. As Hejlsberg puts it, “It’s a line-by-line port, not a rewrite.”
What Corsa Means for Your Editor
Most of your coding happens in an editor—VS Code, Visual Studio, or whatever you love. Corsa turbocharges that experience:
- Faster Startup: Loading VS Code’s 1.5 million lines drops from 9.6 seconds to 1.2 seconds (8x faster).
- Snappy Features: Auto-complete, “go to definition,” and “find references” feel instant.
- Less Memory: Corsa uses about half the RAM of the current version, with more savings coming.
They’re also switching to the Language Server Protocol (LSP), a standard that’ll make TypeScript play nicer with all editors. Say goodbye to laggy mornings—your editor will be ready when you are.
The Roadmap: TypeScript 6 vs. TypeScript 7
Corsa isn’t replacing TypeScript overnight—it’s a journey. Here’s the plan:
- TypeScript 5.8: Out now (March 2025).
- TypeScript 5.9: Coming soon, still JavaScript-based.
- TypeScript 6.x: The current JS version evolves with tweaks to prep for Corsa.
- TypeScript 7.0: The native Corsa version, fully featured by late 2025.
Key dates:
- Mid-2025: A preview of
tscfor command-line type-checking. - End of 2025: Full compiler and editor support in TypeScript 7.0.
The team will maintain TypeScript 6 (JS) for a while, so you can stick with it if Corsa’s missing something you need. Eventually, they’ll align both versions, making the switch seamless.
How to Try Corsa Right Now
Want to test the speed yourself? Corsa’s code is live on GitHub (microsoft/typescript-go). It’s open-source, just like TypeScript, and you can build it today:
- Clone the Repo:
git clone https://github.com/microsoft/typescript-go.git - Follow the README: It’s got build instructions for Go (you’ll need Go 1.22+).
- Run It: Try
tscon your project and see the difference!
It’s not feature-complete yet (e.g., some edge cases might fail), but it’s a sneak peek at the future.
Why This Matters in 2025
A 10x faster TypeScript isn’t just about saving time—it’s a game-changer:
- Big Projects Win: Huge codebases like VS Code or Playwright become manageable.
- AI Gets Smarter: Fast builds mean AI tools can analyze more code, faster.
- New Features: Speed unlocks fancy refactorings and error checks that were too slow before.
Posts on X call it “a dream come true” and “mind-blowing.” Developers are already imagining instant builds and lag-free editors—2025 might be the year TypeScript takes over!
Challenges and What’s Next
Corsa’s not perfect yet:
- Incomplete Features: Some TypeScript tricks (like complex plugins) aren’t ported.
- Learning Curve: Go’s quirks might trip up JS devs contributing to it.
- Rust Debate: Some still argue Rust would’ve been better (but Go’s winning for now).
Next steps include:
- More performance tweaks.
- A new compiler API.
- Full LSP support.
- An AMA on Discord (March 13, 2025, 10 AM PDT)—join and ask questions!
Final Thoughts
TypeScript Project Corsa is a rocket booster for developers. By porting TypeScript to Go, the team’s delivering 10x faster builds, zippy editors, and a foundation for tomorrow’s AI tools—all while keeping the TypeScript you love. Whether you’re coding a tiny app or a million-line monster, Corsa’s speed will make your day better.