# TypeScript Gets a Rust Rewind: A New Era for Faster Development Tools
The JavaScript development world is about to get a significant speed boost. A team of developers from Cloudflare, VoidZero, and Owner.com — led by Max Schwenk — are working on a Rust-based reimplementation of the TypeScript compiler called **tsrs**. This project is being nurtured as part of the **Oxc JavaScript compiler toolchain**, and its primary mission is simple: make TypeScript faster, leaner, and more accessible than ever before.
## Why Does This Matter?
Every developer knows the frustration of waiting for a type check to finish. In large codebases, those waits can stretch from seconds into minutes — or longer. By rewriting the TypeScript compiler in Rust, the team behind tsrs aims to drastically cut down that waiting time. Early tests show tsrs running up to **eight times faster** than TypeScript 7.0 while using roughly **70% less memory**, all while running the same number of type-checking workers.
But the benefits go beyond raw speed. A lighter, more efficient compiler means that rich development environments — including full-blown IDE experiences — could one day run directly inside a web browser or on lightweight devices. This opens the door to coding tools that were previously too heavy or resource-hungry for such environments.
## How Is This Being Done Responsibly?
One of the most important things to understand is that **tsrs is not a fork of TypeScript**. The team has been clear about this from the start. The TypeScript language itself remains under the full control of the TypeScript team at Microsoft, who have guided its design and growth for years. Tsrs simply follows the decisions made by the TypeScript team and translates them faithfully into Rust.
This is a crucial distinction. The TypeScript team sometimes takes years to carefully explore options and prototypes before choosing the right implementation path. A Rust port needs to stay tightly aligned with those choices — otherwise, it risks drifting out of compatibility. The goal is preservation, not reinvention.
## The Rust Advantage
You might wonder: there’s already a TypeScript port written in Go that delivered massive speed improvements. Why build another one in Rust?
The answer lies in **WebAssembly (Wasm)**. While Go works well for many tasks, it comes with a garbage collector that adds overhead when compiled to WebAssembly. Rust’s memory model, on the other hand, allows clean and efficient interaction between Wasm modules and their host environments — no garbage collector required. This makes Rust a natural fit for running development tools in browsers, embedded systems, and IoT devices.
Cloudflare Workers already have strong Wasm support, and recent updates have added native Rust compilation capabilities. This means entire development toolchains — build systems, linters, and compilers — could eventually run in a fully sandboxed environment on Cloudflare infrastructure or even directly in a user’s browser.
## What’s on the Roadmap?
The team is already planning several key steps forward. First, they are collaborating with Theo Browne to merge two existing Rust-based TypeScript implementations — **tsc-rs** and **tsrs** — into a single comprehensive package that supports TypeScript’s full feature set, including Language Server Protocol (LSP) and content mappers.
To keep this project in sync with upstream TypeScript changes, the team is adopting a maintenance process inspired by Vinext, a Cloudflare project that stays aligned with Next.js. Each morning, automated agents review changes, fetch diffs, and flag potential compatibility issues. Each night, test suites are regenerated and run against the project. When gaps are found, agents help identify the relevant changes, build reproductions, port tests, and propose fixes.
The team also plans to contribute performance improvements back to the original TypeScript Go implementation wherever possible — a collaborative approach that benefits everyone in the ecosystem.
## Looking Ahead
tsrs joins a growing family of Rust-based tools in the JavaScript ecosystem, including Vite, Rolldown, Oxlint, and Oxfot — all hosted and supported by Cloudflare. With over ten million developers building on Cloudflare’s platform, the potential impact of a faster, more portable TypeScript compiler is enormous.
The Oxc team is already refactoring its codebase to take advantage of tsrs. Future integrations could include type-aware linting rules in Oxlint, deeper tooling support, and new possibilities for agent-driven development workflows.
The ultimate vision is straightforward: run tsrs as a thriving open-source project that enhances the JavaScript developer experience without ever overshadowing the TypeScript language itself.
—
## Frequently Asked Questions
**What is tsrs?**
Tsrs is a compiler tool that reimplements TypeScript in the Rust programming language. It is designed to be a faithful, high-performance alternative to the original TypeScript compiler (tsc).
**Who is behind tsrs?**
The project is a collaboration between Cloudflare, VoidZero, and Owner.com, with Max Schwenk leading the development effort alongside the TypeScript team and the Oxc project.
**Is tsrs a fork of TypeScript?**
No. Tsrs is a port, not a fork. It faithfully follows the TypeScript language design and decisions made by the official TypeScript team. The TypeScript team retains full control over the language’s direction.
**How much faster is tsrs?**
Early benchmarks indicate tsrs can be up to eight times faster than TypeScript 7.0 and uses approximately 70% less memory when running with the same configuration.
**Can I try tsrs right now?**
Yes. Tsrs is available as an experimental npm package. You can install it with `npm install tsrs` and run it using `npx tsrs`.
**Why was Rust chosen for this project?**
Rust offers excellent WebAssembly support and memory efficiency without a garbage collector, making it ideal for running development tools in browsers, edge environments, and embedded devices.
**Will tsrs stay in sync with TypeScript updates?**
Yes. The team is building an automated maintenance process that reviews upstream TypeScript changes daily, runs compatibility tests nightly, and proposes fixes for any divergences.
**What are the long-term goals?**
The team aims to merge existing Rust-based TypeScript implementations into one package, contribute performance improvements back to the TypeScript ecosystem, and integrate tsrs into tools like Oxlint, Vite, and Rolldown.
—
## Conclusion
The arrival of tsrs marks an exciting chapter for the JavaScript and TypeScript development ecosystems. By leveraging Rust’s speed and memory efficiency — combined with Cloudflare’s infrastructure and open-source ethos — developers stand to gain a faster, more portable, and more accessible type-checking experience. The project’s commitment to staying aligned with the TypeScript team’s vision ensures that this isn’t just another experimental fork; it’s a carefully maintained tool designed to complement and enhance the existing TypeScript landscape.
As the project moves from experimental to stable, keep an eye on how it integrates with the broader Oxc toolchain and developer workflows. Faster builds, richer browser-based IDEs, and more efficient edge computing are all within reach.
Thank you for reading
