Skip to Content

TypeScript-Go toolchain

ttsc

Build with TypeScript-Go. Run scripts only after they type-check. Let plugins see the same types the compiler sees.

10x

faster type checks

TypeScript-Go checks natively, in parallel. JavaScript tsc does neither.

800x

faster lint loop

Rules reuse the AST and types the compiler already built. ESLint parses it all again.

90%

fewer agent tokens

Agents read one compiler-resolved graph over MCP instead of crawling source files.

type-safe

script execution

ttsx type-checks the whole project before Node receives the entrypoint.

Read the guide->Try the Playground
compiler path
1
ttsc

build / check / watch

2
ttsx

checked script runner

3
@ttsc/lint

rules as compiler diagnostics

4
@ttsc/graph

code map for coding agents, over MCP

5
plugins

AST + Checker before emit

src/index.ts:3:7 - error TS2322

Type errors and lint rules land in the same diagnostic stream.

[Toolchain]

One compiler path, not a pile of wrappers.

Keep the existing tsconfig.json. The same project graph feeds the CLI, runner, linter, editor, bundlers, and plugins.

01

read tsconfig

02

type-check

03

run plugins

04

emit, execute, or report

[Diagnostics]

Type errors and lint errors should look like one failure.

ttsc can print rule violations as TS diagnostics. Local runs, CI, and the editor all point at the same file, line, and rule.

type errors

lint violations

format fixes

editor underlines

$ npx ttsc --noEmit
src/index.ts:3:7 - error TS2322: Type 'number' is not assignable to type 'string'.
src/index.ts:2:5 - error TS17397: [prefer-const] Use const instead of let.
src/index.ts:1:1 - error TS11966: [no-var] Unexpected var, use let or const instead.


1  var x: number = 3;
   ~~~~~~~~~~~~~~~~~~
2  let y: number = 4;
       ~~~~~~~~~~~~~
3  const z: string = 5;
         ~
4  
5  console.log(x + y + z);

Found 3 errors in the same file.

[Coding agents]

Your agent should ask the compiler, not grep.

@ttsc/graph hands a coding agent a checker-resolved graph of your project, over MCP. On the agent-cost benchmark, Claude agents answer reading zero files, cutting tokens by roughly 90%.

Connect an agentFull benchmark
.mcp.json
{
  "mcpServers": {
    "ttsc-graph": {
      "command": "npx",
      "args": ["-y", "@ttsc/graph"]
    }
  }
}
The whole setup. It never writes into CLAUDE.md or AGENTS.md.

GPT-5.6 Sol, shared onboarding question. Every model and repository: full benchmark.

[Plugins]

Plugins get the compiler's eyes.

A plugin is not a string replacement pass. It runs beside the TypeScript-Go AST and Checker, then reports diagnostics or rewrites source before JavaScript is emitted.

Explore plugins

runtime code from types

typia

Validators, JSON serializers, LLM tools, and Protobuf codecs generated before runtime.

backend contracts

nestia

NestJS routes, OpenAPI documents, SDKs, and E2E scaffolding backed by typia.

[Playground]

Try the compiler path in the browser.

The playground boots the WebAssembly build of ttsc in a worker. Your source stays in the tab while you test diagnostics, transforms, and emitted output.

Open the Playground->Read wasm docs
01edit TypeScript
02run ttsc.wasm
03inspect diagnostics
04compare output

globalThis.ttsc.build()

Same engine shape as the CLI, packaged for in-tab demos and plugin playgrounds.

[Sponsors]

Built with help from people who keep the work moving.

Sponsor support funds the quiet work behind ttsc: TypeScript-Go upgrades, platform binaries, plugin compatibility, documentation, and the playground.

Sponsor ttsc

Thank you for your support

ttsc sponsors
Last updated on