Tag: WebAssembly

On October 20, 2026, two pieces of news arrived for anyone who writes TypeScript every day. Microsoft released the beta of TypeScript 7.1, the second version of the compiler rewritten in Go. On the same day, Cloudflare introduced tsrs, a port (that is, a faithful rewrite in another language) of the compiler to Rust.

A port is like a translator’s work: the book moves into another language, but the plot stays the same. For a compiler, the plot is the rules of the language, and the errors it reports should be identical.

But what does this mean, in practice, for anyone who runs tsc on their own code? Just consider that on the mui-docs project, the best of the five cases Microsoft measured, type-checking drops from 22.2 to 11.9 seconds with the beta [1].

The two announcements arrived together, but they are not the same thing. One is an official beta, with the Release Candidate, that is, the version that may become the final release, announced for about a month later; the other is an experimental project. Let’s try to separate the measured facts from the announcements.

In short:

The TypeScript 7.1 beta, released by Microsoft on October 20, 2026, type-checks faster than 7.0 according to Microsoft’s measurements and can be tried on a test branch. For tsrs, the Rust port, Cloudflare claims higher numbers, but measured with its own tests and on an experimental version. For a project in production, as of October 22, 2026, there is nothing to change.

• TypeScript 7.1 Beta (October 20, 2026): on five real-world codebases, Microsoft measures type-checking 1.2 to 1.9 times faster than 7.0 and 15.8% to 49.6% less memory.
• tsrs (October 20, 2026): in Cloudflare’s tests, with 4 threads on four projects, tsrs is up to 8 times faster than TypeScript 7.0.2, with about 70% less memory; these are not Microsoft’s tests.
• Next steps: Microsoft announces the 7.1 Release Candidate “in about a month” from October 20, 2026; tsrs aims for a stable version aligned with TypeScript 7.1.

What was announced on October 20, 2026?

Two different compilers for the same language were announced. Microsoft released TypeScript 7.1 Beta, which on the npm registry corresponds to version 7.1.0-beta. It follows TypeScript 7.0, the first native compiler in Go, released by Microsoft on July 8, 2026 [1] [4] [5].

Cloudflare introduced tsrs in a post signed by Boshen Chen, Dimitri Mitropoulos, and Christoph Nakazawa. The project comes from the work of Max Schwenk, of Owner.com, and Cloudflare writes that it is incubating it within Oxc, a collection of JavaScript tools written in Rust. In the post, Cloudflare says it is working on it together with VoidZero and in close collaboration with the TypeScript team [2] [3].

Besides speed, 7.1 brings some new features for people who write code and for people who build tools [1] [4]:

• import attributes (metadata such as with { type: "css" } attached to an import) can be declared in ambient modules (the ones described with declare module, usually in .d.ts files);
• support arrives for source phase imports, that is, import source, useful for example for WebAssembly modules;
• es2026 becomes a stable --target and --lib;
• a new API (the interface through which other programs use the compiler) arrives for external tools, different from TypeScript 6’s; 7.0 had none.

For example, anyone importing CSS or Markdown files could declare a module for each extension; with 7.1 the declaration is tied to the import attribute, and TypeScript reports an error if the import is missing the required attribute. For tool authors, what matters instead is the API: with 7.0, Microsoft had made sure TypeScript 6 could run side by side for tools that need to access the compiler from code, such as typescript-eslint [1] [4].

What is the difference between TypeScript 7 in Go and tsrs in Rust?

The main difference is who maintains it and how far along it is. TypeScript 7 is Microsoft’s official compiler, written in Go, and version 7.0 has been stable since July 8, 2026. tsrs is a Rust port of the 7 compiler, maintained by others and, as of October 22, 2026, still experimental [2] [4].

In practice, anyone who installs the typescript package from npm is already using the Go compiler, and the command is still tsc. tsrs is a separate package, with the tsrs command, which compiles like tsc and accepts almost all of its options (the exceptions come later) [3] [4].

Cloudflare writes that the project is not a fork: the TypeScript team remains responsible for the language, and tsrs follows its behavior “in close collaboration” with that team [2].

The repository README, for its part, states two goals. The first is a stable version aligned with TypeScript 7.1, with 100% conformance; the second is to replace, without changes (drop-in), the compiler and language server (the program that gives the editor completions, errors, and code navigation) of TypeScript 7. It does, however, point out that the project is not affiliated with or endorsed by Microsoft [3].

The code is distributed under the Apache-2.0 license, as a derivative work of TypeScript. External pull requests are closed, while the repository’s tracker accepts bug reports [3].

Why a Rust port, if the Go one works? Cloudflare’s answer is WebAssembly, which I cover further on [2].

How much faster is TypeScript 7.1 than 7.0?

According to Microsoft, the TypeScript 7.1 Beta is 1.2 to 1.9 times faster than 7.0 on the five codebases it measured (post of October 20, 2026). The test uses the default configuration of 4 type-checking threads and the --noEmit option, which checks types without generating JavaScript files. So these are times for a type check, not for a continuous integration (CI) pipeline, and the gain varies from project to project [1].

Codebase	TypeScript 7.0	TypeScript 7.1 Beta	Speedup (Microsoft)	Less memory
bluesky	4.48 s	3.89 s	1.2×	15.8%
mui-docs	22.2 s	11.9 s	1.9×	49.6%
sentry	19.6 s	15.1 s	1.3×	20.8%
t3code-server	26.5 s	19.1 s	1.4×	24.6%
vscode	21.6 s	17.7 s	1.2×	17.2%

The gain, however, is not the same for everyone: on mui-docs the time is almost cut in half, while on bluesky and vscode the speedup is 1.2 times. So it pays to measure on your own code [1].

For 7.0, Microsoft had written that the Go compiler was often around 10 times faster than TypeScript 6, the previous version, written in TypeScript, as Cloudflare describes it. The two measurements come from different tests, on projects that only partly overlap: multiplying 10 by 1.9 gives a number that no source has measured. The sources give no direct numbers between 7.1 and the 5.x versions [1] [2] [4].

What did the move to TypeScript 7 mean outside the charts? In the 7.0 post, dated July 8, 2026, Microsoft reported that, according to Slack’s engineers, after moving to TypeScript 7, their type-checking in CI had dropped from about 7.5 to 1.25 minutes [4].

So the figure is about the move to TypeScript 7, not 7.1, and Microsoft does not say which version Slack was coming from. It should be taken for what it is: a testimonial collected by Microsoft [4].

Cloudflare, in its post, speaks of a 7.1 beta “up to 2.5x faster” than 7.0. But be careful: in Cloudflare’s charts the version measured is a nightly build (7.1.0-dev.20261019.1), not the beta, and the maximum value there is 2.58× on the MUI docs project [2].

These are two different measurements, not to be put side by side or compared with each other: the same MUI docs, on 7.0, takes 22.2 seconds in Microsoft’s tests and 10.44 in Cloudflare’s [1] [2].

How fast is tsrs, according to Cloudflare?

In Cloudflare’s early benchmarks, tsrs is up to 8 times faster than TypeScript 7.0, with the same number of checker threads. The comparison is between tsrs 0.18.0-ts7.1.0-dev.20260929, which ports a development version of 7.1 to Rust, and TypeScript 7.0.2, with 4 threads (--checkers 4) and --noEmit [2] [3].

The projects are VS Code, MUI docs, webpack, and t3code server, and the measure is real elapsed time (wall time). The post does not state the hardware [2].

In the chart with TypeScript’s default configuration (4 threads), Cloudflare reports type-checking from 3.83 times (VS Code) to 8.10 times (MUI docs) faster. Peak memory drops to between 0.13 and 0.31 times that of 7.0.2, that is, from 87% to 69% less (MUI docs and webpack). In the text, Cloudflare sums it up as “~70% less memory” [2].

The same chart also includes the 7.1 nightly, that is, the nightly build mentioned above: it is the closest comparison to 7.1 to be found there. Cloudflare does not make this comparison, but the times are there:

Project	tsrs	7.1 nightly
VS Code	1.73 s	5.28 s
MUI docs	1.29 s	4.05 s
webpack	0.23 s	0.71 s
t3code server	1.21 s	7.17 s

Working out the ratio, tsrs comes out about 3 times faster than the nightly on the first three projects and about 6 times faster on t3code server [2].

This should be read with two caveats. tsrs is based on a development version of 7.1 from late September (7.1.0-dev.20260930.4), the nightly is from October 19, and neither of them is the beta. In addition, Cloudflare’s post states neither the machine nor how tsrs was built [2].

As already said for 7.1, it matters who did the measuring: here it is tsrs’s own developers. Cloudflare writes that it worked with the TypeScript team to make sure the tests compare the same configuration, and it publishes the scripts in the repository’s bench folder. It also adds that some of the 7.1 optimizations come from tsrs, while Microsoft’s post does not mention tsrs [1] [2] [3].

A detail for anyone trying it: out of the box, tsrs does not use 4 threads but an adaptive configuration that, according to Cloudflare, is faster but uses more memory. For a like-for-like comparison with tsc, both need the same --checkers value [2].

Why do we need a TypeScript compiler in WebAssembly?

It lets the compiler run where a native program cannot go, such as the browser or an isolated environment (sandbox). WebAssembly is a binary format that browsers and runtimes execute in a portable and secure way. As of October 22, 2026, the tsrs README points to a playground in the browser, where you can try type-checking and code generation [3].

According to Cloudflare, a Go program compiled to WebAssembly has to carry its own garbage collector, the system that frees unused memory. Rust, on the other hand, does not need one, and this simplifies exchanging data with the environment that hosts it. The WebAssembly package is called @tsrs/wasm and, according to the README, uses the wasm32-wasip1 target [2] [3].

Cloudflare mentions three possible uses: sandboxed development tools for AI agents, the browser, and embedded or IoT devices (Internet of Things, connected objects). The first is the closest to its own work: an agent can run the entire development toolchain in an isolated environment on Cloudflare’s platform [2].

Will tsrs replace the official TypeScript compiler?

In a project it can take its place, because it is designed to replace tsc without changes. As the reference for the language, no: Cloudflare writes that it is not a fork and that decisions about the language remain with the TypeScript team [2] [3].

The replacement also covers the editor: the repository documentation explains how to start the language server with tsrs --lsp -stdio. The same document warns that the language server does not yet run content mappers, the plugins through which TypeScript 7.1 checks files such as Vue or Svelte files [1] [3].

There are still known differences, however. The README mentions the order in which some diagnostics appear and the lack of support for --init and --showConfig. Cloudflare also writes that it is working with Theo Browne to merge tsrs and tsc-rs, another Rust port, into a single package with a language server and content mappers [2] [3].

It remains to be seen how such a large project can stay aligned with the original. For tsrs, Cloudflare wants to use the method it already applies to Vinext: an agent that reads the original project’s changes every morning, and compatibility tests rerun every night.

AI also shows up in another part of the post. To explain why a port like tsrs is arriving precisely in 2026, Cloudflare argues that the most advanced AI models can do large ports “almost independently in a matter of days” [2].

Cloudflare, however, does not say how much of tsrs was written this way, nor does it attach any data. In the post, though, it links to the one by Max Schwenk on Owner.com, dated October 19, 2026, which presents tsrs as “A Rust port of TypeScript, written entirely by agents” [2] [7].

I wrote about the limits of these models in A.I. – Artificial Intelligence and Discrimination. An LLM (Large Language Model, the kind of model behind chatbots) picks the most likely word and can produce content that is coherent but false, the so-called hallucinations. For a compiler, then, tests count for more than announcements.

How do you try the TypeScript 7.1 beta and tsrs on your own project?

You install the beta as a development dependency, with the command given by Microsoft [1]:

npm install -D typescript@beta

In a test run on October 22, 2026, on Linux x86_64 (Debian 13, Node.js 20.19.2) and in an empty project, the command prints:

added 2 packages, and audited 3 packages in 2s

found 0 vulnerabilities

To check the version:

npx tsc --version

Version 7.1.0-beta

On October 22, 2026, this is the version that corresponds to the beta tag on npm, while latest is still 7.0.2. Before merging it into the main branch, it is a good idea to run type-checking in CI and read the new errors [5].

Microsoft in fact points out two changes that can make some appear. The first concerns the DOM types (the interfaces through which code uses the web page in the browser) in lib.d.ts. The second is a stricter check on distributive type parameters, with a new error message, which Microsoft explains with a simple image: “a Cat might be a subtype of Animal, but it certainly won’t be a subtype of every type of Animal” [1].

If you use Vue, Svelte, Astro, or MDX, you can also look at content mappers: Microsoft warns, however, that the example package for Vue is not yet on npm [1].

For tsrs, Cloudflare gives the shortest form, npm install tsrs and then npx tsrs. The project README instead recommends installing it as a development dependency and running it with --noEmit, which checks types without generating JavaScript. With npm, it looks like this [2] [3]:

npm install -D tsrs
npx tsrs --noEmit

In the same test run, the installation adds two packages, tsrs and its binary for Linux x64. On a small test file (src/index.ts) with two type errors, npx tsrs --noEmit prints the same lines as tsc 7.1.0-beta and exits with code 2:

src/index.ts(4,7): error TS2322: Type 'string' is not assignable to type 'number'.
src/index.ts(5,20): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.

With correct code it prints nothing and exits with 0, and in neither case does it write files. It is a single test file, so it says nothing about conformance in general.

Why --noEmit in particular? Without that option, tsrs behaves like tsc: it reads tsconfig.json and generates the JavaScript files, and in the same test run it generated them even with the type errors. There is a reason for -D too: without it, npm adds tsrs to the production dependencies.

To see which TypeScript version it is based on:

npx tsrs --version

Version 7.1.0-dev.20260930.4 (tsrs 0.18.0-ts7.1.0-dev.20260929, microsoft/TypeScript@b85298b6a81f)

As the output shows, tsrs is based on a development version of TypeScript, 7.1.0-dev.20260930.4, and not on the beta. The package name, on the other hand, carries September 29: as of October 22, 2026, the version published on npm is 0.18.0-ts7.1.0-dev.20260929 [6].

Before trying it, it is worth checking your system. Version 0.18.0 has binaries only for macOS on Apple Silicon and for Linux x64 and arm64, with both glibc and musl (the two most widely used C libraries on Linux; musl is the one Alpine uses). No Windows and no Mac with an Intel processor [6].

If the check fails or gives results different from tsc, the report goes in the tsrs repository’s tracker on GitHub, which accepts bug reports with a minimal reproduction. tsrs is not a Microsoft project [3].

What should you do before the final release of 7.1?

My advice, while waiting for the final release, is to keep production on TypeScript 7.0, which remains the stable version, and to try the 7.1 beta on a separate branch. tsrs is worth following, especially for anyone working with browsers, WebAssembly, or agents, but it should be treated as an experiment [1] [5].

Tool authors, such as those writing plugins or editor integrations, have more reasons to try the beta: Microsoft is asking for feedback on the new API. Anyone working on Linux or on a Mac with Apple Silicon can instead run tsrs alongside tsc with --noEmit and compare the errors, without touching the build [1].

It remains to be seen whether Microsoft’s Release Candidate will confirm the beta’s numbers, and whether tsrs will reach the stable version it has promised.

---

Frequently asked questions

Why did Microsoft write TypeScript 7 in Go and not in Rust?

To stay as close as possible to the existing code. In the “Why Go?” discussion in the typescript-go repository (March 5, 2025), Ryan Cavanaugh of the TypeScript team explains that a port was needed, not a rewrite, and that Go, written idiomatically, resembles the style of the original code. The garbage collector, he adds, carries little weight in the TypeScript codebase. Cloudflare chose Rust for WebAssembly, where it does not have to carry a garbage collector along.

How much faster is TypeScript 7.1 than 7.0 and earlier versions?

From 1.2 to 1.9 times faster than 7.0, according to Microsoft’s measurements of October 20, 2026 on five codebases, with 4 threads and --noEmit. For 7.0, Microsoft had indicated about 10 times the speed of TypeScript 6: different tests, not to be multiplied. The sources report no direct comparisons with the 5.x versions.

Can I use the TypeScript 7.1 beta in production?

Better not: it is a beta, and Microsoft says nothing about production use. The Release Candidate is announced for about a month after October 20, 2026, with the final release shortly after. It is best to try it on a separate branch and in CI, checking for new errors in the DOM types and on distributive type parameters.

Does typescript-eslint work with TypeScript 7?

Not directly with 7.0, which has no API for external tools. In its July 8, 2026 post, Microsoft explains that it made sure TypeScript 6 can run side by side, with the @typescript/typescript6 package, for tools such as typescript-eslint. The 7.1 Beta brings a new API; in the typescript-eslint tracker (issue #10940), support for 7.1 was a work in progress in late September 2026.

Can I use tsrs instead of tsc in my project?

Yes, for testing: the README presents it as a drop-in replacement for the TypeScript 7 compiler and language server. As of October 22, 2026, the version on npm is 0.18.0, which is based on a development version of 7.1, not on the beta, and has no binaries for Windows or for Macs with an Intel processor. You install it with npm install -D tsrs and run it alongside tsc with npx tsrs --noEmit.

How do I try the TypeScript 7.1 beta on my project?

With npm install -D typescript@beta, the command given by Microsoft on October 20, 2026, on a dedicated branch and with type-checking in CI. For tsrs, the README gives -D and --noEmit: with npm, npm install -D tsrs and npx tsrs --noEmit. Version 0.18.0 binaries exist only for Linux and for macOS on Apple Silicon.

---

Sources

1. Microsoft (Daniel Rosenwasser and the TypeScript team), “Announcing TypeScript 7.1 Beta,” October 20, 2026 – https://devblogs.microsoft.com/typescript/announcing-typescript-7-1-beta/
2. Cloudflare (Boshen Chen, Dimitri Mitropoulos, Christoph Nakazawa), “Introducing tsrs: A port of TypeScript to Rust,” October 20, 2026 – https://blog.cloudflare.com/typescript-rust-port/
3. Oxc project, oxc-project/tsrs repository on GitHub (README, documentation in docs/, and bench folder), accessed October 22, 2026 – https://github.com/oxc-project/tsrs
4. Microsoft (Daniel Rosenwasser), “Announcing TypeScript 7.0,” July 8, 2026 – https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/
5. npm registry, typescript package (dist-tags: beta = 7.1.0-beta, latest = 7.0.2), data read from the registry on October 22, 2026 – https://registry.npmjs.org/typescript
6. npm registry, tsrs package (latest = 0.18.0-ts7.1.0-dev.20260929, Apache-2.0 license, per-platform binaries in optionalDependencies), data read from the registry on October 22, 2026 – https://registry.npmjs.org/tsrs
7. Owner.com (Max Schwenk, Head of AI Developer Experience), “tsrs,” October 19, 2026 – https://building.owner.com/tsrs
8. Microsoft (Ryan Cavanaugh, TypeScript team), “Why Go?” discussion in the microsoft/typescript-go repository, March 5, 2025 – https://github.com/microsoft/typescript-go/discussions/411
9. typescript-eslint, issue #10940 “Enhancement: Use TS 7 (tsgo / typescript-go) for type information” (update by Josh Goldberg, late September 2026), accessed October 22, 2026 – https://github.com/typescript-eslint/typescript-eslint/issues/10940