tsrs: a Rust port of TypeScript, and what it changes for you today

On October 20, 2026, Cloudflare and VoidZero announced tsrs, a port of the TypeScript compiler to Rust, built with Max Schwenk of Owner.com and incubated inside the Oxc toolchain. The short version for a working developer: it is experimental, it does not change the TypeScript language, and you do not need to switch anything this week. The longer version is more interesting, because it says a lot about where type checking is going.

A port, not a fork

The authors are firm on this point. They write that they are not forking TypeScript and that the TypeScript team should stay in full control of the language's design. tsrs follows the team's decisions instead of making its own, and the post explains why: a port that drifts from the original will, in their words, eventually fall apart and become incompatible.

That matters for your code. A fork could, over time, accept programs that the official compiler rejects, or the other way round. A faithful port aims for the same answers, only faster. The authors also admit current differences, for example the order in which diagnostics are printed, and say they want those down to a minimum before a stable release.

What the benchmarks claim

These are Cloudflare's numbers, not mine, and I have not run them. According to the post, tsrs is up to 8x faster and uses about 70% less memory than TypeScript 7.0 with the same number of type check workers. The same post says TypeScript 7.1 beta is itself up to 2.5x faster than 7.0, and that some of those gains were upstreamed from tsrs.

Two details keep this honest. First, the authors note that ports often publish big numbers by using larger machines and non-default options, and say they worked with the TypeScript team to compare the same configuration. Second, tsrs ships by default with an adaptive configuration that uses more memory to go even faster, so the default you install is not the setting behind the memory figure.

Why Rust, when Go already made it 10x faster

The post asks this question itself. TypeScript's own port to Go already made the compiler 10x faster than the version written in TypeScript. The authors' answer is WebAssembly. A Go program compiled to Wasm has to carry Go's garbage collector with it. Rust has no garbage collector to ship, and its memory model makes it simple to pass memory between a Wasm guest and its host.

Cloudflare's interest is plain: it runs build systems on Workers, where a small memory footprint pays off quickly. The same property is what could let a full development toolchain run in a browser tab, or on an embedded device, without a server behind it.

What it changes for a normal project today

Very little, and that is fine. tsrs is an experimental release. If you are curious, the post gives exactly two commands:

npm install tsrs
npx tsrs

As general guidance, I would treat it as a second opinion, not a replacement. Run it next to your normal tsc check on a branch, compare the errors, and note the time. Do not make it the gate that blocks a merge while the authors themselves say the output still differs in places.

Where you will feel this first is CI. Type checking is often one of the slowest steps in a TypeScript pipeline, and every faster compiler shortens it. The cheapest win right now is probably not tsrs at all but moving to the newest official TypeScript release, since the post credits 7.1 beta with its own large gain.

Next step: time your current type check in CI so you have a real number to compare against when a stable tsrs, or the next TypeScript release, arrives. Source: Cloudflare blog, Introducing tsrs: A port of TypeScript to Rust.