TypeScript is being ported to Go | interview with Anders Hejlsberg
Why Hacker News recommends it
HN points to it as the authoritative answer to why the team picked Go rather than C# or Rust, citing timestamps on cyclic data structures and garbage collection.
What it is
An interview with Anders Hejlsberg, lead architect of TypeScript, about porting the TypeScript compiler to Go. He covers the 10x type-checking speedup, lower memory use, and why Go was chosen.
Recommended by 2 HN commenters across 1 different months, 2025 to 2025.
What Hacker News said
Recommends duckerude · 2025-03 · on “A 10x Faster TypeScript”
Anders Hejlsberg explains here: [this video] . TL;DW: - C# is bytecode-first, Go targets native code. While C# does have AOT capabilities nowadays this is not as mature as Go's and not all platforms support it. Go also has somewhat better control over data layout. They wanted to get as low-level as possible while still having garbage collection. - This is meant to be something of a 1:1 port rather than a rewrite, and the old code uses plain functions and data structures without an OOP style. This suits Go well while a C# port would have required more restructuring.
Recommends yohannesk · 2025-03 · on “A 10x Faster TypeScript”
If you are wondering why not Rust instead of Go, they outline why Rust was not chosen. This is a port not a reimplementation. Many of the data structures can not easily be ported to Rust, such as Nodes with cyclic dependencies. Check the longer interview here: [this video] Also, I think the discussion on esbuild's choice of language applies here as well as it has a large similarity. You can find it here on hn
Cites fixprix · 2025-03 · on “A 10x Faster TypeScript”
Anders answers that question here - [this video] Transcript: "But I will say that I think Go definitely is much more low-level. I'd say it's the lowest level language we can get to and still have automatic garbage collection. It's the most native-first language we can get to and still have automatic GC. In contrast, C# is sort of bytecode-first, if you will. There are some ahead-of-time compilation options available, but they're not on all platforms and don't really have a decade or more of hardening. They weren't engineered that way to begin with. I think Go also has a little more expressiveness when it comes to data structure layout, inline structs, and so forth."
Cites bokwoon · 2025-03 · on “A 10x Faster TypeScript”
[this video] [19:14] why not C#? Dimitri: Was C# considered? Anders: It was, but I will say that I think Go definitely is -- it's, I'd say, the lowest-level language we can get to and still have automatic garbage collection. It's the most native-first language we can get to and still have automatic GC. In C#, it's sort of bytecode first, if you will; there is some ahead-of-time compilation available, but it's not on all platforms and it doesn't have a decade or more of hardening. It was not geared that way to begin with. Additionally, I think Go has a little more expressiveness when it comes to data structure layout, inline structs, and so forth. For us, one additional thing is that our JavaScrip
Cites xanth · 2025-03 · on “A 10x Faster TypeScript”
I think the much larger ask C# couldn't answer is the "expressive" access to low level struct layout[1] [1] [this video]
Cites emn13 · 2025-05 · on “Past, present, and future of Sorbet type syntax”
While I'm most familiar with C#, and haven't used Ruby professionally for almost a decade now, I think we'd be better off looking at typescript, for at least 3 reasons, probably more. 1. Flowsensitivity: It's a sure thing that in a dynamic language people use coding conventions that fit naturally to the runtime-checked nature of those types. That makes flow-sensitive typing really important. 2. Duck typing: dynamic languages and certainly ruby codebases I knew often use ducktyping. That works really well in something like typescript, including really simple features such as type-intersections and unions, but those features aren't present in C#. 3. Proof by survival: typescript is empirically
Cites homebrewer · 2025-05 · on “Type-constrained code generation with language models”
Hejlsberg mentioned the ability to quickly provide accurate type information to LLMs as one of the reasons for rewriting tsc into Go: [this video]
Cites osigurdson · 2025-06 · on “Why Go Rocks for Building a Lua Interpreter”
Yeah. They said that there were lots of nested structures with cycles and so on so it would be hard to do with Rust. Link below. [this video]