ts-rust is worth evaluating alongside your existing compiler if slow TypeScript checks cost you time and you can compare diagnostics before switching. Keep your current compiler authoritative if you need an immediately dependable replacement across native builds, editors and WebAssembly. Our source build succeeded in 336 seconds, but the test command reached its 900-second limit.
The useful question is whether a particular tsc-rs package gives your project the answers it expects. The issue history contains both inherited upstream regressions and genuine port bugs. That distinction decides whether changing package versions, correcting project configuration or waiting for a port fix will help.
What people use ts-rust for
ts-rust, distributed as tsc-rs, runs TypeScript compiler tooling implemented in Rust while your application's source stays TypeScript. The project README describes a port of Microsoft's native Go compiler, including the checker, language server and API. It is a toolchain change, not a language migration.
These reports show more than a repository announcement:
| Who used it | What they did | Reported outcome |
|---|---|---|
| GitHub user jmfrank63 | Ran the WebAssembly checker inside the iso-agents runtime, checking each agent iteration | A previously overflowing 5,000-term binary chain returned HTTP 200 with the correct verdict on build 91f3d021c. Consumer report in #99 |
| Kenny and kennysarnoski-jarvis | Checked an Effect server and reduced a middleware inference error after upgrading | They stayed on 0.3.0; explicit middleware type arguments also cleared the error on 0.5.0. Effect report in #79 |
| GitHub user paoValle | Reproduced application benchmarks and counted checker ancestor walks | Maintainers integrated a control-flow-container memo into accepted revision R183 after the report. Profiling discussion in #27 |
| GitHub user jakeleventhal | Reduced an incompatible generic-method assignment from Polotno | Maintainers reproduced the error in the exact upstream compiler and tested a proposed upstream patch against the original assignment. Polotno report in #25 |
The agent-runtime report is particularly useful. A consumer took a failing generated input back through an HTTP harness and reported the result after changing builds. That is evidence for one repaired path in a real integration. The Effect report demonstrates a different adoption cost: matching upstream behavior can still force a developer to roll back.
For an ordinary application, start with the documented command, npx tsc-rs -p tsconfig.json, alongside the compiler you already use. Keep both outputs. A faster check that changes an important diagnostic is a migration decision, even if the change originated in Microsoft's implementation.
What happened when we ran it
Our November 14 quickstart attempt at commit 91f3d021c4f1 stopped at the snippet step because the recipe found no JavaScript/TypeScript code block to run. The run used a fresh unprivileged container configured with 2 CPUs and 4 GB RAM, no secrets and no published ports. It selected npm package tsc-rs 0.8.0.
| Quickstart observation | Outcome | What it means |
|---|---|---|
| Recipe | quickstart-lib | This recipe looked for a library example, rather than supplying an application to check. |
| Snippet step | FAILED: the README has no JavaScript/TypeScript code block to run | The attempt produced no compiler verdict on an application. |
| Recorded finding | no-snippet | The runner stopped before a representative TypeScript task. |
| Teardown | ok | The run record reports cleanup completed. |
That failure needs a narrow reading. The README gives a shell command that points the compiler at a tsconfig. The quickstart recipe instead wanted a runnable library snippet. Its failure says that this route to an example stopped, not that the compiler rejected valid TypeScript. A useful follow-up would supply an application and retain its diagnostics.
The separate source harness ran on November 13 at commit 91f3d02, with 3 CPUs, 12 GB RAM and image label lab-rust:1. Those are recorded sandbox settings. The label alone does not identify the actual Rust version or operating-system version.
| Source-harness step | Recorded result | Editorial reading |
|---|---|---|
| Install | Succeeded in 15 seconds; 68 dependencies recorded | The recorded preparation step completed. |
| Build | Succeeded in 336 seconds | Source compilation completed within the harness allowance. |
| Tests | Timed out in 900 seconds; cargo test summary: 4 passed, 0 failed of 4 | The suite did not finish, despite the successful reported subset. |
The test-log tail contains successful thp_guard checks and transpile checks, including rejection of directory access and URL filenames with a query or fragment. It shows no failure explaining the timeout. The summary's four passes are not a complete-suite count: the tail itself contains more successful lines. Calling this a clean test run would erase the most consequential result.
The source scan recorded 2,314 files, roughly 961,552 source lines and a 146.5 MB checkout. It found four CI workflow files, no Dockerfile and no tests directory. Inline test names in the log show why the last observation cannot mean that the project has no tests. These source-harness results also explain why contributors should budget more than an npm command when planning compiler work.
Where people get stuck: upstream regressions and port bugs need different fixes
Issue #50 records a genuine macOS path-resolution divergence, while #79 records an Effect inference regression inherited from a newer upstream pin. Treating both as generic incompatibility hides the remedy. The issue discussion and the package containing a fix matter more than whether a thread's badge says closed.
| Symptom and source | What the record found | Action supported by the record |
|---|---|---|
| False duplicate-casing errors through macOS workspace symlinks, #50 | Version 0.3.0 canonicalized paths differently from Go | The maintainer reports the fix released in 0.4.0, with macOS CI coverage. |
| Effect middleware produces a string where a Layer is expected, #79 | Versions 0.4.0 and 0.5.0 followed a newer upstream revision than their docs said | The reporter stayed on 0.3.0 or supplied explicit middleware type arguments on 0.5.0. |
| Polotno generic addElement assignment fails, #25 | The exact upstream pin produced the same diagnostic | Maintainers tested an upstream patch successfully; the supplied discussion ends before its merger. |
| Generated ts-proto Exact helper reports TS2344 and TS2536, #12 | Later comparisons reproduced the diagnostics in the pinned upstream compiler | Use the matching upstream revision when reducing the error; closure did not mean the behavior changed. |
| Build mode reads stale or missing output | The README describes imports of another project's output without a project reference | Add the missing project reference. |
Kenny's Effect case is the one to keep in mind during upgrades. The same server passed on 0.3.0 and failed on the next versions. The documentation still named the older comparison compiler. Maintainers corrected the pin documentation on main at d6204a7f9, and the reporter found a type-argument workaround. Correcting the documentation fixed the investigation baseline, not the application's inference error.
The Polotno thread reaches the same lesson by another route. The reporter supplied a small reduction of an actual assignment. Maintainers ran the exact upstream revision, reproduced the error, then tested a candidate upstream patch against both the reduction and Polotno. That sequence gives you a useful escalation path: retain the real failure, reduce it and compare against the right oracle before assigning blame.
Small WebAssembly stacks still hurt deep emit and nested syntax
Issue #99 separates a repaired binary-chain checking path from remaining recursive parser, flow-analysis and emit paths. Its maintainer reports binder and checker work stacks on main in R223, with release delivery still pending in that comment. A native checker succeeding therefore does not answer whether a browser or worker host can handle the same input.
The consumer confirmation is specific: jmfrank63 reports a 5,000-term guest passing over HTTP on 91f3d021c after earlier overflow. That makes the change useful for agent-generated code, where checking happens repeatedly and unusual expression shapes can reach the compiler. It does not turn the still-open thread into a statement that all deep syntax is safe.
A separate WebAssembly panic in issue #83 affected ordinary narrowing callbacks passed to filter, find and every. The maintainer traced it to a wasm32 cache-marker overflow and reports the fix on main at f32007823. This was a target-specific failure: the report says native builds of the same commit were fine. Keep the execution target in every compatibility report.
For a hosted checker, put a reproducible deep input and a normal application input through the actual host. Record whether the task checks only or also emits JavaScript. Raising a worker stack helped cases described in #99, but the thread explicitly identifies hosts such as workerd where that knob is unavailable. Choosing a host and choosing an input policy are part of using this compiler.
ts-rust vs TypeScript 7, Bun and tsrs
The current README reports tsc-rs 0.6.0 faster than TypeScript 7 across six applications, while Bun leads the overall comparison. These are project-reported results, separate from our source build and incomplete test run. The README's dated Blacksmith comparison uses different hardware and builds from the earlier Mac-based review tables.
| Alternative | Why consider it | Decision that the evidence supports |
|---|---|---|
| Microsoft TypeScript 7 / tsgo | It is the native upstream behavior tsc-rs aims to follow | Keep it as the comparison oracle at the exact pin used by your tsc-rs version. |
| bun check | It leads the cited six-app comparison overall | Compare diagnostics as well as elapsed time, because the README reports different outputs. |
| TypeScript 6 | It is the older JavaScript compiler baseline | Retain it when its accepted behavior matters to your project; its larger relative speed gaps do not describe the advantage over native Go. |
| tsrs | Cloudflare and VoidZero describe a separate Rust port and consolidation work with tsc-rs | Track its own package and benchmark configuration rather than transferring its claims to this repository. |
| Aleph-Alpha/ts-rs | It generates TypeScript declarations from Rust types | Choose it for shared data types, not for checking an existing TypeScript application. |
Sources: current project benchmark and known problems, earlier comparison coverage, Cloudflare's tsrs announcement, Aleph-Alpha's binding generator.
Bun's lead is a reason to include it in an evaluation, not to assume equivalent answers. The current README says the pinned TypeScript 7, tsc-rs and fast mode produced identical diagnostics in that six-app comparison, while Bun reported none on those inputs. For an existing CI check, differences in reported errors deserve review before a faster checker becomes authoritative.
The comparison should use the settings you intend to keep. The README says fast mode can change checker allocation with available CPUs and describes diagnostic changes near certain limits. Default mode and fast mode deserve separate entries in your evaluation. Copying the fastest headline into a CI proposal skips that decision.
What the other reviews get wrong
The supplied coverage mixes historical pins and token-cost accounts, and the launch's broad replacement claim needs the platform qualifications exposed by later issues. Those errors can send a reader to the wrong compiler or the wrong conclusion about what was demonstrated.
The daily.dev summary attributes roughly $420,000 in token costs to the successful Claude rewrite. The project account separates earlier OpenAI attempts from approximately $24,047 of API-priced Opus usage. Those are reported token valuations, with subscription usage also described, rather than independently audited cash expenditure. daily.dev summary, project-history coverage.
The September 29 upstream pin in the earlier reviews is historical. Issue #79 explains the move in 0.4.0 to the October 8 pin and the stale docs shipped through 0.5.0. The current README now names the October 19 TypeScript 7.1 beta pin, while explicitly identifying October 8 as the pin for 0.4.0 through 0.8.0. Reading main's README alone can therefore give a different baseline from the installed release.
The launch's drop-in description also needs the subsequent record. A real macOS workspace divergence reached a release fix in 0.4.0. A WebAssembly-only narrowing panic reached main at f32007823. These repairs are reasons to look closely at the project, but they rule out reading the announcement as proof for every platform and execution target.
Security decisions start with the execution boundary
The November 14 lab recipe ran unprivileged, without secrets or published ports, and issue #99 demonstrates a compiler reachable through a consumer's HTTP harness. Those are different security situations. A local development command and a service accepting generated source need different operating limits.
Our recommendation for a hosted checker is to isolate each workload, restrict which files it can access and cap execution resources. The deep-input reports give a concrete availability reason for doing so. A compiler's ability to match upstream diagnostics says nothing by itself about safe multi-tenant hosting. Keep the compiler process separate from deployment credentials and private application secrets when checking untrusted input.
The README's Rust implementation does not settle memory safety either. The supplied discussion asks about unsafe code and idiomatic Rust without providing a reviewed inventory. Code ownership matters here: the author says he has never read a line of it. Teams making it a critical build dependency should decide who will investigate a compiler failure and how they will roll back a package change.
Questions people ask
The TypeScript 7.1 programmatic API is supported in the version-specific #80 response, including named entry points. Other questions need the same care about package identity and evidence.
ts-rust is pingdotgg's Rust port of Microsoft's native TypeScript compiler, distributed as tsc-rs. It checks TypeScript applications and provides compiler tooling. It does not convert application code into Rust. The README describes preserving Go's algorithms and behavior, which explains why a faithful port can inherit an upstream regression.
Where is the ts-rust GitHub repository?
The ts-rust GitHub repository is pingdotgg/ts-rust. Its npm package is tsc-rs. Aleph-Alpha/ts-rs is a different project for generating TypeScript declarations from Rust data types, and Cloudflare's tsrs announcement concerns another compiler port and consolidation effort. Similar names do not make their features interchangeable.
Does ts-rust support the TypeScript 7.1 programmatic API?
Yes: the maintainer's #80 response confirms API support and names tsc-rs/unstable/sync, tsc-rs/unstable/async and tsc-rs/unstable/ast. It describes the client starting the binary with --api and gives 0.6.0 as its example version. Use that version-specific answer rather than an assumption that the project stops at TypeScript 7.0. API support thread.
How much unsafe code does ts-rust use, and is it idiomatic Rust?
The supplied evidence gives no audited unsafe-code count. The README says the port keeps Go's algorithms and behavior; explainx's account records the community's question about unsafe and idiom. Preserving another implementation's semantics is a different engineering objective from rewriting it in idiomatic Rust. An implementation review is needed to answer the count and safety questions. Discussion account.
Can compiler ports validated against existing tests still have hidden compatibility gaps?
Yes. The macOS workspace-casing divergence and WebAssembly-only predicate panic are concrete examples of behavior that required later repairs. Existing comparisons cover particular inputs, platforms and execution targets. Those reports make adding your actual monorepo, editor workflow or Wasm host to an evaluation a reasonable engineering step, even when upstream conformance results look encouraging.
Does the planned AST flow-record layout change already remove control-flow container walks?
No. In #27, the maintainer says that the flow-record layout step was dropped. A separate control-flow-container memo subsequently landed in R183. The reporter counted repeated walks without claiming a measured speedup. Treat the merged memo as the documented change, rather than attributing it to a layout project that the response says was removed. Ancestor-walk discussion.
What we have not tested yet
Our evidence stops short of a completed source test suite or an application compiler verdict from the quickstart recipe. We have not reconciled the full cargo logs, identified the actual toolchain versions, reproduced the benchmark comparisons, exercised the 7.1 API or run an editor session. No vulnerability audit, unsafe-code inventory or production service security assessment is included.
The research records leave further boundaries: deep emit and other nested syntax retain small-stack limits, the proposed Effect and Polotno upstream patches lack confirmed merger in the supplied extracts, and a fix on main is not automatically a fix in the package you installed. The consumer's HTTP success is one reported case, not our own agent-runtime run or a sustained-load result.
All four rating cards are unassessed. Source preparation and build completion provide concrete observations, but the unfinished tests and missing application task do not support a setup-ease score for this adoption route. Issue discussions show useful maintenance work without measuring support capacity. Documentation breadth and conformance claims also need an explicit assessment before they become numerical ratings.
Before replacing a working compiler, retain its output, record the tsc-rs package version and matching upstream commit, and run the same project configuration through both. For WebAssembly, include the actual host and emit setting. The result you need is a faster check whose diagnostic differences you understand.


