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.
Three CLIs Β· one toolchain
Build it, run it,
teach your editor about it.
Same plugin contract across the entire toolchain β what your build sees, your runtime sees, and your editor sees.
ttsccliBuild Β· Check Β· Transform
Built on @typescript/native-preview, with a plugin host that runs typia, lint, and friends in the same pass. Same tsconfig.json you already have.
npx ttsc --watch- βNative TypeScript-Go speed
- βPlugin-powered emit
- βfix / format subcommands
ttsxcliRun TypeScript, typed.
Like tsx, but it actually type-checks before it runs. Real diagnostics, real failures, no transpile-only surprises.
npx ttsx src/index.ts- βReal type-check on every run
- βPlugin transforms applied first
- βPreload modules with --require
ttscservercliLSP for ttsc plugins.
Embeds TypeScript-Go's LSP and proxies plugin diagnostics, code actions, and commands into your editor β through a single stream.
code --install-extension <built-vsix>- βEditor sees plugin diagnostics live
- βPlugin code actions & commands
- βBuild `packages/vscode-ttsc`; Marketplace tracked for v1
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.
1import typia, { tags } from "typia";2import { v4 } from "uuid";34interface 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}1213const matched: boolean = typia.is<IMember>({14 id: v4(),15 email: "samchon.github@gmail.com",16 age: 30,17});18console.log(matched); // true
ttscβ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";67const 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.
Plugin host
Plugins ship Go.
You ship TypeScript.
Plugin descriptors live in JS so youβre using ttsc with npm install. The transform logic itself is Go β sharing TypeScript-Goβs AST and Checker β so it stays fast.
@ttsc/bannerTransformJSDoc banners in emit
Adds @packageDocumentation banners to the top of emitted files. The smallest transform plugin β a great first read.
npm install -D @ttsc/banner@ttsc/lintDiagnosticsLint as compile errors
ESLint-style engine with 140 rules, including a Wadler-style format/print-width line reflow. Diagnostics appear in the same stream as type errors.
npm install -D @ttsc/lint@ttsc/pathsTransformResolve tsconfig path aliases
Rewrites path aliases in JS and declaration emit so consumers get real relative imports without a post-build step.
npm install -D @ttsc/paths@ttsc/stripTransformRemove debug code from emit
Strips configured function calls and debugger statements. Pair it with banner for a clean production build.
npm install -D @ttsc/stripEcosystem plugins
Already shipping on ttsc. PRs welcome to extend the list.
@ttsc/unplugin
Plugins run in your bundler too.
Same plugin contract, embedded inside the bundlers youβre already using.
What you get
One toolchain
across build, run, and edit.
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
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
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
@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
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
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.