Understanding TS18003: No Inputs Were Found in tsconfig.json for TypeScript Builds

By the end of this page, you will understand what the TypeScript error TS18003: No inputs were found in config file means, how tsconfig.json decides which files to compile, and how to fix this problem by correctly using include, exclude, and project file locations.

TS18003 means the TypeScript compiler looked at your tsconfig.json and could not find any TypeScript input files to compile.

TypeScript does not compile a project by guessing randomly. It builds a list of input files using these rules:

• If you use a files array, only those files are compiled.
• If you use include, matching files are compiled.
• If you use neither, TypeScript uses default include patterns such as **/*.
• Then exclude removes matching paths from that set.

If the final result contains zero TypeScript source files, the compiler reports TS18003.

In practice, this usually happens for one of these reasons:

• There are no .ts or .tsx files in the folder covered by tsconfig.json.
• The tsconfig.json file is placed in a folder that does not contain the source files you expect.
• Your exclude patterns remove everything.
• Your source files were moved, renamed, or generated elsewhere.
• Build tooling changed after an IDE or compiler update and now validates the config more strictly.

Why this matters:

Think of tsconfig.json as a file filter for a folder.

• include says: "Look in these places."
• exclude says: "Ignore these places."
• files says: "Use exactly these files."

Now imagine TypeScript as a worker filling a basket with source files:

1. Start in the folder where tsconfig.json lives.
2. Collect files that match the include rules.
3. Throw away files that match the exclude rules.
4. Compile what remains.

If the basket ends up empty, you get TS18003.

So the error does not usually mean TypeScript itself is broken. It usually means: "I followed your file selection rules, and there was nothing to compile."

The main tsconfig.json properties related to this error are:

{
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules", "dist"],
  "compilerOptions": {
    "outDir": "dist",
    "target": "es6"
  }
}

What each part means

• include: where TypeScript should look for input files.
• exclude: paths to skip.
• compilerOptions.outDir: where compiled JavaScript should go.

Example 1: A working setup

Project structure:

project/
  tsconfig.json
  src/
    app.ts
  dist/

Consider this small project:

Scripts/
  tsconfig.json
  main.ts
  helpers/
    math.ts
  node_modules/
  ../wwwroot/app/

tsconfig.json:

{
  "include": ["**/*.ts"],
  "exclude": ["../wwwroot/app", "node_modules"],
  "compilerOptions": {
    "outDir": "../wwwroot/app"
  }
}

Step-by-step

1. TypeScript starts in the folder containing tsconfig.json.
2. It reads include: ["**/*.ts"].
3. It searches for all .ts files under that folder.
4. It finds:
   • main.ts

This concept shows up often in real projects:

Frontend apps

A web app may keep source files in src/ and compiled files in dist/.

• include points to src/**/*.ts
• exclude skips dist and node_modules

ASP.NET Core projects

A project may place TypeScript under Scripts/ and emit JavaScript into wwwroot/.

• Source: Scripts/**/*.ts
• Output: wwwroot/app
• exclude prevents TypeScript from re-reading generated output

Monorepos

Multiple apps may each have their own tsconfig.json.

• Each config needs the correct folder scope
• A misplaced config can accidentally point to no files

Build pipelines and CI

A local IDE might appear fine, but CI can fail if:

In real projects, developers usually make file matching explicit instead of relying on defaults.

Common pattern: explicit include

{
  "include": ["Scripts/**/*.ts"],
  "exclude": ["node_modules", "wwwroot", "bin", "obj"]
}

This avoids confusion when the project grows.

Common pattern: keep source and output separate

Developers often structure projects like this:

• src/ or Scripts/ for source
• dist/ or wwwroot/ for compiled output

This prevents accidental re-compilation of generated files.

Common pattern: guard against empty configs

When setting up a project, teams often either:

• add a starter index.ts file, or

Here are the most common causes of TS18003.

1. No .ts files exist

Broken setup:

{
  "compilerOptions": {
    "outDir": "dist"
  }
}

If the project has no TypeScript files yet, the compiler has nothing to build.

Fix: add at least one .ts file or remove the TypeScript build step.

2. tsconfig.json is in the wrong folder

If tsconfig.json is inside Scripts/, TypeScript searches relative to Scripts/, not the project root.

Fix: either move tsconfig.json or use correct relative include paths.

3. Excluding your source folder

Broken config:

vs

{
  "compilerOptions": {
    "target": "es6",
    "outDir": "dist"
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules", "dist"]
}

Quick rules

• tsconfig.json paths are relative to the location of tsconfig.json.
• include chooses candidate files.
• exclude removes files from that set.
• files overrides discovery with an exact list.
• outDir is where compiled output goes, not where source should be read from.
• TS18003 means the final input file list is empty.

Why does TypeScript say no inputs were found?

Because after applying include, exclude, and default rules, the compiler found zero TypeScript source files.

Does outDir affect which files are compiled?

No. outDir controls where compiled JavaScript is written. It does not define source inputs.

Is TS18003 a TypeScript bug?

Usually no. It normally means the config points to no valid input files.

Can upgrading Visual Studio cause this error to appear?

Yes. An upgrade can surface configuration problems that were previously ignored or handled differently.

Should I use include explicitly?

Yes, in most projects it is clearer and easier to maintain than relying on defaults.

What should I include for an ASP.NET Core project?

Usually the folder that contains your .ts files, such as Scripts/**/*.ts or ClientApp/src/**/*.ts.

Why exclude wwwroot or dist?

Those folders often contain generated JavaScript output. Excluding them prevents TypeScript from treating generated files as source inputs.

• tsconfig.json file structure — understanding how TypeScript project configuration works.
• include, exclude, and files — these directly control which files are compiled.
• TypeScript compiler options — settings like target, module, and outDir shape the build.
• Glob patterns — file matching patterns such as **/*.ts are central to input discovery.
• outDir and build output folders — helps separate source code from generated files.
• ASP.NET Core static files and wwwroot — relevant because compiled frontend assets are often emitted there.
• TypeScript project structure — organizing src, Scripts, dist, and generated output clearly prevents build issues.
• IDE vs CLI builds — editor tooling and command-line compilation may expose configuration problems differently.