tsc-ts Released: An Experimental TypeScript Compiler Written in TypeScript

On October 17, 2026, a post about tsc-ts appeared on Hacker News. tsc-ts is an experimental port of the TypeScript 7.0.2 compiler, known as TypeScript-Go or tsgo, to TypeScript. The resulting code is compiled into a native executable using scriptc. Developers can install the package via npm and run it on their own projects. Comparisons with tsgo provide a useful reference, but they are no substitute for testing it yourself.

What Was Ported and How It Was Tested

The tsc-ts package includes a compiler, a command-line tool, and an API server. After installing it via npm, you can run the compiler with a tsconfig.json file. This uses a native binary provided by an optional dependency for your platform. The repository also contains reference builds of tsgo, whose output is used to compare the ported compiler’s behavior.

The port covers scanning and parsing code, building the syntax tree, binding symbols, resolving modules, and type checking. The compiler also handles project settings, reports diagnostics, and emits JavaScript and declaration files. The --build, --incremental, and --watch modes have been tested. The question is not just whether the compiler can read a source file: the comparisons also cover what it reports and writes to disk.

According to the tsc-ts repository’s README, the comparisons use the TypeScript test suite: around 12,500 files and 17,000 test units after splitting up multi-file cases. Scanner results matched tsgo across every file in the suite; parser and syntax tree results matched across every test unit; and module resolution matched across every request. For type checking, the README reports matching diagnostics across all files.

File output was compared separately. JavaScript output was tested with 39 sets of options, with matching results across all units compared. Declaration output is reported to match across all units; build and incremental-mode scenarios were also compared with tsgo. These are the results of the tests listed, not a promise that the compilers will behave identically on every project.

The repository includes commands for rerunning comparisons with tsgo and benchmarking against tsgo and the JavaScript-based TypeScript compiler. The material presented does not include final performance figures. The scope of the test suite alone cannot tell you whether the new version will be faster on a particular codebase.

API, Builds, and Project Limits

The --api mode communicates over standard input and output. It exposes the same API as tsc --api version 7.0.2, so a tool that uses that interface can run tsc-ts in its place. The material names scriptc as one such tool. Server responses are compared separately with those from tsc --api; builds of the same programs using scriptc with both compilers are also tested.

Language service methods are supported for completions, JSDoc tags, documentation comments, and symbol usage information. Methods for starting CPU profiling and saving a heap profile are not supported, however. If completions need auto-imports, the server reports that requirement, as tsc --api does. API compatibility should therefore not be taken to mean that every possible method is available.

Building from source requires Node.js 24+ with npm, Go 1.26, macOS, Linux, or Windows as the environment for scriptc, and clang for linking. The project pins scriptc 0.3.6 and its streams package; according to the README, the build fails with a different scriptc version. There are steps for building the Node.js version, the native binary, and the reference tsgo builds. Installing the published package via npm is separate from those steps.

No timeline has been given for leaving experimental status. There is also no claim that tsc-ts will replace tsgo or the familiar TypeScript compiler. Anyone following ports of language tools might also want to look at the experimental port of the TypeScript 7 compiler to Rust.

What Website Developers Should Check

If your project uses TypeScript, you can start by installing tsc-ts as a development dependency and running it with your project’s tsconfig.json. Then compare its diagnostics and output files with those from your current build. If your project relies on tools that use tsc --api, check the methods they need separately: the list of supported calls does not imply support for profiling.

The test suite results show which parts of the compiler have already been compared with tsgo. They cannot tell a developer whether their website’s build will change or how long it will take. Given the experimental status and the lack of published performance figures, that remains something to test on your own code.

My Take

I’m interested in the port to TypeScript and in the way its components are compared with tsgo individually. I’d first run tsc-ts on a small practice project and look at the diagnostics and build output. For now, I don’t see a reason to replace a familiar tool with it without doing that check.

For a straightforward landing page, I’d rather write the markup without complicating the toolchain. I’d turn to tsc-ts when I wanted to understand how the compiler works or test its compatibility with a specific project.

Sources

Where the news comes from. The text is a retelling in the author’s own words; the facts come from the source, the opinion is the author’s.

1. tsc-ts: TypeScript written in TypeScript github.com

About the author

Tural Latyp

aspiring frontend developer

I write practice interfaces and build small pages. Right now I’m learning about image loading and basic APIs.

All posts by the author