Up to 8x faster and about 70% less memory than TypeScript 7.0, with the same number of type-checking workers. Those are the first numbers for tsrs, the Rust port of the TypeScript compiler that Cloudflare, VoidZero and Max Schwenk (Owner.com) unveiled on October 20, 2026. The same day, Microsoft shipped the TypeScript 7.1 beta, its Go-based compiler, with gains of up to 1.9x in its own benchmarks. If you maintain a large TypeScript monorepo, the question is whether it is already worth looking beyond the official compiler.
What tsrs is
tsrs is a faithful port of the TypeScript 7 compiler (tsc) and its language server, written in Rust and incubated inside Oxc, the toolchain behind Oxlint and Oxfmt. It is Apache-2.0 licensed and lives at oxc-project/tsrs.
Cloudflare is emphatic that this is not a fork: the TypeScript team still owns the language, and tsrs commits to following its implementation to the letter. The work happens in collaboration with that team, and some tsrs optimizations have already been upstreamed into the Go compiler.
Two details explain why it is showing up now:
- AI made it feasible. According to Cloudflare, only one attempt to port TypeScript had ever succeeded, Microsoft's own move to Go, but frontier models can now carry out ports this large almost on their own in a matter of days. Maintenance will rely on agents too: they review upstream changes every day, open issues and propose a fix whenever the test suite exposes a divergence. It is the same process Cloudflare uses to keep Vinext in sync with Next.js.
- The goal is WebAssembly, not just speed. A Go program compiled to Wasm has to carry its garbage collector along; Rust does not. With a TypeScript compiler that has a small memory footprint, Cloudflare wants to run complete development environments inside Workers, in the browser or on embedded devices, and to power type-aware lint rules in Oxlint.
How to try it
The package is on npm as an experimental release. The latest version, published on October 19, 2026, is 0.18.0-ts7.1.0-dev.20260929: the suffix tells you which TypeScript build the port tracks.
npm install tsrs
npx tsrsTo compare it with what Microsoft ships, install the 7.1 beta in the same project:
npm install -D typescript@beta
npx tsc --noEmitThe useful test is running both against the same repository with --noEmit and comparing time, memory and, above all, the diagnostics each one reports.
Putting the numbers in context
Benchmarks between TypeScript ports have become hard to trust, and Cloudflare admits as much: many use bigger machines or non-default options. That is why it says it agreed with the TypeScript team to compare identical configurations. Even so, three separate jumps are in play and should not be blended:
- TypeScript 7.0 vs 6: moving from JavaScript to Go made the compiler roughly 10x faster, according to Microsoft.
- TypeScript 7.1 beta vs 7.0: with 4 workers and
--noEmit, Microsoft measures between 1.2x (bluesky, vscode) and 1.9x (mui-docs), and 16% to 50% less memory. Cloudflare's chart puts the gain at up to 2.5x. - tsrs vs 7.0: up to 8x and about 70% less memory with the same workers. By default tsrs uses an adaptive, machine-dependent setting that trades more memory for even more speed.
In short, the fair comparison for tsrs is against 7.0, and the version you will actually run a month from now is 7.1, which already closes part of the gap.
tsrs vs TypeScript 7.1
| tsrs | TypeScript 7.1 beta | |
|---|---|---|
| Language | Rust | Go |
| Maintained by | Oxc (VoidZero), Cloudflare, Max Schwenk | TypeScript team (Microsoft) |
| Status | Experimental, 0.18.0 | Beta; RC in about a month, final shortly after |
| Speed | Up to 8x vs 7.0 | 1.2x–1.9x vs 7.0 |
| Memory | ~70% less than 7.0 | 16%–50% less than 7.0 |
| Tooling API | TypeScript 7's unstable JS API | New API with typescript/sync, typescript/async, typescript/ast… |
| WebAssembly | Design goal | Not its focus |
| Compatibility | Known differences, such as diagnostic order | It is the reference |
| License | Apache-2.0 | Apache-2.0 |
Where tsrs wins and where it loses
It wins on what it measures: type-checking time and memory. In a CI pipeline running tsc --noEmit over a large monorepo, memory is often what forces you onto pricier runners, and 70% less changes the machine size you need. It also wins if you want to compile TypeScript where Go is a poor fit: a Wasm sandbox, the browser, a Worker.
It loses on everything that is not performance. It is an experimental 0.x package with acknowledged differences from the official compiler, and a planned merge with tsc-rs, Theo Browne's port, is still needed to cover every feature, including the language server and content mappers. There is no stable release tracking 7.1 yet either: the ts7.1.0-dev suffix shows it sits one step behind the beta.
What interests me most is the maintenance model. Keeping a faithful compiler port alive with agents that replay every upstream change is an experiment that, if it works, will matter well beyond TypeScript. If it fails, you will notice it as a type error tsc doesn't report, or the other way round. That is the concrete risk: tsrs and tsc disagreeing, and your CI passing code the official compiler rejects.
Verdict
Who should try it: teams whose monorepos spend most of their CI time or memory on type checking, willing to run it as an extra step alongside tsc and compare results. And anyone building tooling on Wasm or Workers, which is what it was designed for.
Who should wait: anyone who needs a single source of truth in CI or relies on the language server in their editor. For them, the sensible move is upgrading to TypeScript 7.1 once it goes final: it is the official compiler, it delivers 1.2x to 1.9x for free and it picks up some of the optimizations coming out of tsrs.
Sources
- tsrs: a Rust port of TypeScript, Cloudflare blog, 2026-10-20
- Announcing TypeScript 7.1 Beta, TypeScript blog (Microsoft), 2026-10-20
- tsrs: A Rust port of the TypeScript 7 compiler (tsc) and language server, npm, 2026-10-19