Skip to Content

TypeScript-Go Β· Compiler Β· Plugin Host

Compile-powered TypeScript
without the wait.

ttsc is a standalone toolchain on TypeScript-Go with first-class plugins, type-safe execution, and a lint engine that speaks compile error.

~/your-project
3
CLIs (ttsc Β· ttsx Β· ttscserver)
4
First-party plugins
140
Lint rules
9
Bundlers supported

Compile-powered plugins

Your types,
turned into JavaScript.

ttsc plugins read the TypeScript AST and rewrite emit at build time. Drop typia.is<T>()into your code β€” the compiler does the runtime check.

src/index.tsInput
1import typia, { tags } from "typia";
2import { v4 } from "uuid";
3
4interface IMember {
5 id: string & tags.Format<"uuid">;
6 email: string & tags.Format<"email">;
7 age: number &
8 tags.Type<"uint32"> &
9 tags.ExclusiveMinimum<19> &
10 tags.Maximum<100>;
11}
12
13const matched: boolean = typia.is<IMember>({
14 id: v4(),
15 email: "samchon.github@gmail.com",
16 age: 30,
17});
18console.log(matched); // true
ttsc→
dist/index.jsEmit
1import * as __typia_transform__isFormatUuid from "typia/lib/internal/_isFormatUuid";
2import * as __typia_transform__isFormatEmail from "typia/lib/internal/_isFormatEmail";
3import * as __typia_transform__isTypeUint32 from "typia/lib/internal/_isTypeUint32";
4import typia from "typia";
5import { v4 } from "uuid";
6
7const matched = (() => {
8 const _io0 = (input) =>
9 "string" === typeof input.id &&
10 __typia_transform__isFormatUuid._isFormatUuid(input.id) &&
11 "string" === typeof input.email &&
12 __typia_transform__isFormatEmail._isFormatEmail(input.email) &&
13 "number" === typeof input.age &&
14 __typia_transform__isTypeUint32._isTypeUint32(input.age) &&
15 19 < input.age &&
16 input.age <= 100;
17 return (input) =>
18 "object" === typeof input && null !== input && _io0(input);
19})()({
20 id: v4(),
21 email: "samchon.github@gmail.com",
22 age: 30,
23});
24console.log(matched); // true

Open the playground to try it on your own code Β· No bundler step required.

What you get

One toolchain
across build, run, and edit.

01

TypeScript-Go speed

Real native compiler, no V8 cold-start

Built directly on @typescript/native-preview. Same emit, same diagnostics, far less time waiting on tsc.

Native binary Β· Type-check + emit in one pass

02

Plugins, the compiler way

JS descriptor + Go transform Β· cached binaries

Plugins ship npm packages with a JS descriptor; the Go transform compiles once and is cached. The compiler, runtime, and LSP all see the same plugin.

tsgo AST Β· Checker Β· cached toolchain

03

ttsx β€” typed execution

Real type-check before run

Replaces tsx / ts-node with native execution that actually fails on type errors. Preload modules with --require, same as Node.

tsx ergonomics Β· ts-node correctness

04

@ttsc/lint

Lint violations as compile errors

140 rules including a Wadler-style format/print-width that reflows objects, arrays, and call sites. ttsc fix writes the corrections back.

ESLint feel Β· Prettier reflow Β· 1 pass

05

Editor-aware via ttscserver

Plugin diagnostics in your editor

ttscserver embeds TypeScript-Go's LSP and proxies plugin diagnostics, code actions, and commands. Build the VSCode extension from packages/vscode-ttsc β€” Marketplace tracked for v1.

LSP host Β· Plugin code actions

06

Bundler-ready with unplugin

Vite Β· Webpack Β· Rollup Β· esbuild Β· 9 more

When the bundler owns your build, @ttsc/unplugin runs the same plugin pass inside it. No custom integrations to maintain.

9 bundler adapters Β· unplugin protocol

Build it today.

npm install -D ttsc @typescript/native-preview
That’s it. Setup is one page.

Last updated on