Does this send my code anywhere?

No. Compilation runs entirely in your browser using the official `typescript` npm package.

Does this type-check my code?

No. It uses TypeScript's single-file `transpileModule` API, which strips types and syntax errors are still caught, but cross-file type errors are not, since there's no full project context.

What ECMAScript target and module format does it emit?

ES2020 for the target and ESNext for the module format, hardcoded compiler options rather than read from a tsconfig.json, since there's no project file for this single-snippet tool to read.

Can I paste JSX or TSX code?

No. The compiler options used here don't enable JSX (there's no `jsx` setting), so pasting JSX syntax will produce a parse error. This tool is scoped to plain TypeScript syntax, not TSX.

TypeScript Compiler - Compile TypeScript to JavaScript Online

Overview

Introduction

Seeing exactly what JavaScript a TypeScript snippet produces usually means setting up a local project and running `tsc`.

This tool transpiles TypeScript to JavaScript directly in your browser using the official TypeScript compiler.

What Is TypeScript Compiler?

A TypeScript-to-JavaScript transpiler using `ts.transpileModule`, the same single-file transpile API used by tools like ts-node and Babel's TypeScript preset.

Type annotations are stripped; the emitted JavaScript targets ES2020.

How TypeScript Compiler Works

`transpileModule` parses and transpiles the single file without full project type-checking.

Syntax errors are reported with their line and column; cross-file type errors aren't caught, since there's no project context.

When To Use TypeScript Compiler

Use it to quickly see what a TypeScript snippet compiles to, or to strip types from a small piece of code for use in a plain JS context.

It's also handy for confirming a specific TypeScript syntax feature (like `as const`, optional chaining, or an enum) transpiles the way you expect before relying on it in a build pipeline.

Often used alongside CoffeeScript Compiler and JavaScript Formatter.

Features

Advantages

Runs entirely client-side.
Uses the official TypeScript compiler package, so emitted output matches `tsc`'s single-file transpile behavior.
Reports syntax errors with their exact line and column, since `transpileModule` still fully parses the file even though it skips type-checking.

Limitations

No cross-file type checking, since only a single file is transpiled with no project configuration.

Examples

Typed function

Input

function add(a: number, b: number): number {
  return a + b;
}

Output

function add(a, b) {
    return a + b;
}

Type annotations are stripped, leaving plain JavaScript.

Best Practices & Notes

Best Practices

For a real project, use `tsc` with your actual `tsconfig.json`; this tool is for quick single-file checks.
Don't treat the absence of an error here as proof your types are correct; run your project's real `tsc --noEmit` (or your editor's type-checking), since this tool only checks syntax, not types.

Developer Notes

Uses `ts.transpileModule()` with `module: ESNext` and `target: ES2020`, dynamically imported so TypeScript's compiler doesn't bloat other tools' bundles.

TypeScript Compiler Use Cases

Quickly seeing what a TypeScript snippet compiles to
Stripping types from a small snippet for use in plain JavaScript

Common Mistakes

Expecting type errors from other files (like an imported interface) to be caught, since only the pasted snippet is transpiled.
Assuming a clean compile here means the code is type-safe; `transpileModule` only catches syntax errors, not type mismatches, unused variables, or missing properties.

Tips

If you need full type-checking, paste the same code into a local TypeScript project instead.
Paste one function or module at a time when debugging a specific transpile question; it keeps the diagnostic line numbers easy to map back to your source.

TypeScript Compiler