Tsrs: A Port of TypeScript to Rust

No matter how many optimizations can be ported from tsrs to ts-go, Rust will be more efficient and enable the WASM use case.

The premise of porting the compiler from TS to GO was ease of migration due to Go's garbage collector. That doesn't hold anymore? AI doesn't care how hard or easy a migration is if a test suite exists.

Could you elaborate on what type of optimizations were added to TS 7.1? As in, were they more algorithmic or related to memory management?

Another advantage human ports have is the opportunity to reconsider earlier architectural decisions and change them, instead of just enshrining them in the new language.

>Create with P::new(value). p.get() returns &'static T. [...] unless an explicit recycling site proves them dead

It's unsound, the LLM/human is doing the proving. They've hidden unsafe in an abstraction without removing the unsafeness. Using the arena allocator's lifetime would have been safe and easy (bumpalo recommends this AFAIK).

I'm guessing a sycophantic LLM either found or praised this load-bearing seam.

Never deallocating would have been sound (missile memory management: https://devblogs.microsoft.com/oldnewthing/20180228-00/?p=98... ).

Built this little vibe-coding app as an experiment/cost exploration: https://glare.run

It's awesome how cheaply you can run an entire agentic coding loop (including compilation & live reload) in their v8 isolate sandbox.

Then why are the performance graphs the headliner topic in the article? The WASM sandbox is barely a footnote.

They didn’t design a language that millions of human engineers enjoy (?, lol) using. They took an existing codebase and ported it. Yes, the porting part is easier now but only because another project and spec exist.

You do have to be worried that it's possibly installing trojan horses on your computer while compiling code, or any other number of unwanted side effects.

But you can and should be able to have integration testing in place to know that a compiler - at a minimum - actually works.

I didn't push performance in a way that would cause big deviations from the Golang project's algorithms and data structures; similar to how the TS team didn't want to deviate too far from the JavaScript source till now. Aggressive unmanaged arenas and object pooling was the direction I would have pursued..

The GC in DotNet is a source of major frustration for a tool like this. Without tuning lots of gen 0/1 work occurs to determine if objects should be promoted. The tuning is still not an ideal solution IMHO. Fully unmanaged arenas and aggressive object pooling could help here, but an alternative GC may be part of an ideal, comprehensive solution.. I have have a play with ZeroGC.

There is a warning on the repo that it's not maintained, but I've been curious about the process of updating it to sync "upstream" changes. And it sounds like the TypeScript team are going to start incorporating some of the performance techniques identified in the Rust port in the 7.1 release so... I'll probably at least sync it to up to 7.1 and keep it as an active experiment and case study on LLM porting and DotNet AOT performance.

It's just good fun.

IIRC at the time of the port to go they wanted fast test and compile time, of course it's a different era now.

This can type check and compile VSCode in less than a second?

True. Looks like main use-case is AI Agent Sandboxing

[0] https://github.com/pingdotgg/ts-rust

Ehm no, added type safety, and dealing with a type checker it's exactly what agents need.

> if no human is coding

Nope outside the bubble there are many still hand coding(me too)

> I guess it will be soon that typescript won’t matter anymore since agents will be writing code is Rust

Oh hold on a second isn't Rust the same as Typescript "adding human readability"?! Why not trashing Rust and just have LLMs output WASM directly? XD Wasm which is basically useless outside the browser or some microvms on the edge, and in the browser you don't even have an interface for directly rendering anything and still have to deal with the dom

You either are highly non technical, very junior or I just don't know

You need a quick reality check.

that same type system exists in the javascript language (jsdoc). doing those type checks is the 'slow' part that makes go / rust appealing. not just stripping types to emit js.