Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?


Failed to load latest commit information.

Build Status

The nodemon for TypeScript

tsc-watch starts the installed TypeScript compiler (tsc) with --watch parameter, with the ability to react to compilation status. tsc-watch was created to allow an easy dev process with TypeScript. Commonly used to restart a node server, similar to nodemon but for TypeScript.

Anything that you can do with tsc you can do with tsc-watch, the only difference is that tsc-watch can react to compilation status.

Argument Description
--onSuccess COMMAND Executes COMMAND on every successful compilation.
--onFirstSuccess COMMAND Executes COMMAND on the first successful compilation.
--onFailure COMMAND Executes COMMAND on every failed compilation.
--onCompilationStarted COMMAND Executes COMMAND on every compilation start event (initial and incremental).
--onCompilationComplete COMMAND Executes COMMAND on every successful or failed compilation.
--maxNodeMem Calls node with a specific memory limit max_old_space_size, to use if your project needs more memory.
--noColors By default tsc-watch adds colors the output with green
on success, and in red on failure.
Add this argument to prevent that.
--noClear In watch mode the tsc compiler clears the screen before reporting
Add this argument to prevent that.
--signalEmittedFiles Will run tsc compiler with --listEmittedFiles, but hiding TSFILE lines. Use it to enable file_emitted event, while keeping tsc stdout silent.
--silent Do not print any messages on stdout.
--compiler PATH The PATH will be used instead of typescript compiler.
Default is typescript/bin/tsc


  • That all the above COMMANDs will be killed on process exit. (Using SIGTERM)

  • A COMMAND is a single command and not multi command like &&

  • Any child process (COMMAND) will be terminated before creating a new one.


npm install tsc-watch --save-dev
## for command-line usage
npm install -g typescript tsc-watch


From Command-Line

## Watching a project (with tsconfig.json)
tsc-watch --onSuccess "node ./dist/server.js"

## Beep on failure
tsc-watch --onFailure "echo Beep! Compilation Failed"

## Watching a single file
tsc-watch server.ts --outDir ./dist --onSuccess "node ./dist/server.js"

## Custom compiler
tsc-watch --onSuccess "node ./dist/server.js" --compiler my-typescript/bin/tsc

From npm script

"dev-server": "tsc-watch --noClear -p ./src/tsconfig.json --onSuccess \"node ./dist/server.js\"",

From javascript

You can see a detailed example here

The client is implemented as an instance of Node.JS's EventEmitter, with the following events:

  • started - Emitted upon the compilation start (initial or incremental).
  • first_success - Emitted upon first successful compilation.
  • subsequent_success - Emitted upon every subsequent successful compilation.
  • compile_errors - Emitted upon every failing compilation.
  • file_emitted - Emitted upon every file transpiled if --listEmittedFiles is used.

Once subscribed to the relevant events, start the client by running watch.start()

To kill the client, run watch.kill()

Example usage:

// Using CommonJS:
const { TscWatchClient } = require('tsc-watch/client');
// Using ES6 import:
import { TscWatchClient } from 'tsc-watch/client';

const watch = new TscWatchClient();

watch.on('started', () => {
  console.log('Compilation started');

watch.on('first_success', () => {
  console.log('First success!');

watch.on('success', () => {
  // Your code goes here...

watch.on('compile_errors', () => {
  // Your code goes here...

watch.start('--project', '.');

try {
  // do something...
} catch (e) {
  watch.kill(); // Fatal error, kill the compiler instance.


  • The (onSuccess) COMMAND will not run if the compilation failed.
  • tsc-watch is using the currently installed TypeScript compiler.
  • tsc-watch is not changing the compiler, just adds the new arguments, compilation is the same, and all other arguments are the same.