How does a team tackle the port of one of the most popular coding languages used every day by millions of developers?
In 2025, TypeScript was the most used language on GitHub, according to the 2025 GitHub Octoverse report. And in July 2026, the TypeScript team released TypeScript 7.0. The new TypeScript is a 10x faster native port designed to streamline the developer experience, with core editor features like auto-completion and diagnostics now taking a fraction of the time they used to. The creator of TypeScript and Microsoft Technical Fellow Anders Hejlsberg recently sat down with host Ryan Peterman to record an episode of The Peterman Pod. They discussed the process of porting from TypeScript to Go, the technical decisions and tradeoffs the team made, and lessons learned along the way. They also talked about Hejlsberg’s approach to creating programming languages, the use of AI to update large codebases, and both the value and limitations of agentic AI today.
Check out the full episode:
From the beginning, TypeScript promised to deliver JavaScript that scales. By incorporating strong type-checking and rich tooling, TypeScript made it possible to build and ship non-trivial, high-quality apps across platforms. “We all stand on the shoulders of giants,” acknowledged Hejlsberg. “No programming language was ever created in perfect isolation, right? Everyone learns from everyone. Someone comes up with a good idea, and then you see it adopted elsewhere. That’s how the industry moves forward, really.”
The TypeScript team worked for more than a year on a native port built in Go that could make the most of modern hardware. The port maintained the structure and logic of the original codebase to keep results consistent and compatible between the two compilers. The key difference: TypeScript 7 brings native code speed, shared memory multithreading, and several new optimizations that typically yield increased speeds of between 8x and 12x on full builds.
“The first decision we made was that we were not going to rewrite,” Hejlsberg said. “We were going to port because only by porting could we preserve the semantics, algorithms, and exact behavior of our existing compiler, which everyone depends on for backwards compatibility. Now, we could have cleaned the slate and started it completely from scratch, but we would have come up with a different language in the sense that it would give you different errors or behave differently in certain situations.”
Next, the team had to decide on a programming language for the port. After looking at some core assumptions made by the TypeScript codebase—the presence of garbage collection as well as the first-class treatment of functions, for example—Go emerged as the clear winner.
“We tried Rust, and it just wasn’t feasible,” noted Hejlsberg. “Garbage collection is done manually, or it’s done through the borrow checker, but the borrow checker doesn’t allow circular data structures. And our complier is chock-full of circular data structures. We have trees with parent pointers; we have types that are recursive. I mean, it’s everywhere. We were trying to optimize for doing as little work as possible to get us to the payout. And Go is great—it’s type-safe and memory-safe—so we got all the benefits for less work by going that route.”
While that approach was integral to the port, early testing and community partnerships also helped ensure a high quality bar. The Visual Studio Code team made an early bet on TypeScript, working closely with the TypeScript team to give developers built-in support for both TypeScript and JavaScript. Recently, VS Code adopted TypeScript 7.0 to speed up their own builds, improve the daily editing loop for agents as well as developers, and ensure that the TypeScript team could ship a more tested release.
Early versions of TypeScript 7.0 were also tested internally at scale by Bloomberg, Canva, Notion, Sentry, Slack, and Vanta, with strong results.
Interestingly, agentic AI didn’t play much of a role in the port—a fact that Hejlsberg chalks up to timing.
“We started this project two years ago,” he said, “and LLMs were nowhere near as good as they are now. That’s how crazy-fast it’s all moved, right?”
The team wrote its prototypes, including the scanner and parser, manually. Once convinced that 10x performance gains were possible, they wrote a tool that syntactically translates TypeScript into Go. That gave them code with no syntax errors, but it didn’t properly compile.
“All of that had to be refactored,” said Hejlsberg. “We had to redo all the data structures, but we got the same codebase out of it. Then we could sort of bang on that and then, in a more localized fashion, use AI occasionally to help us with the transformation. Now, if we were to start the project today, would we do it differently? Possibly, although I will say that if we just let AI loose on the code in the old compiler and asked it to translate it all, I don’t know if that would absolve us from then having to go in and carefully examine every line that came out of it to make sure there were no hallucinations. Unless you have 100% perfect test coverage, you probably still have to go back and check all of that.”
As for working with AI, Hejlsberg called out that LLMs are stochastic—something we should all keep in mind as we determine when and where to deploy these tools.
“That’s always the thing about AI that people forget: It’s not deterministic, right? So you can’t really trust that it’ll do the same thing twice. But it’s very good at writing programs, so it’s kind of funny. Sometimes you don’t ask AI for the answer. You ask it for a program that computes the answer.”
Now, the team uses AI daily in its work: helping to write tests, move pull requests, and more.
“Whenever an issue is logged, the first thing we do is put Copilot on it and see if it can fix it for us,” Hejlsberg explained.
Read the TypeScript 7.0 announcement post and install it.