Ninja

Purpose

Guide agents through Ninja as a build executor: diagnosing failures, controlling parallelism, generating from CMake, and understanding the .ninja file format when needed.

Triggers

• "Ninja is failing — how do I get more output?"
• "How do I use Ninja with CMake?"
• "How many parallel jobs does Ninja use?"
• "How do I add a custom build step in Ninja?"
• "What is a build.ninja file?"

Workflow

1. Ninja as a CMake generator

The most common use of Ninja is as the build executor for CMake:

# Configure with Ninja
cmake -S . -B build -G Ninja
cmake --build build                    # uses ninja internally

# Or invoke ninja directly
cd build && ninja

# Specify parallelism
ninja -j4
ninja -j$(nproc)

# Build specific target
ninja myapp
ninja install

CMake also supports Ninja Multi-Config:

cmake -S . -B build -G "Ninja Multi-Config"
cmake --build build --config Release
cmake --build build --config Debug

2. Verbose output and diagnostics

# Show full commands (not just [CC] foo.c)
ninja -v

# Dry run (show what would be built)
ninja -n

# Show why a target needs rebuilding
ninja -d explain myapp

# Print all targets
ninja -t targets all

# Print targets grouped by rule
ninja -t targets rule cc

# Dependency graph (graphviz)
ninja -t graph myapp | dot -Tsvg -o deps.svg

3. Common Ninja flags

Flag	Effect
-j N	Parallel jobs (default: CPUs + 2)
-l N	Don't start new jobs if load average > N
-k N	Keep going after N failures (default 1)
-v	Verbose: show full command lines
-n	Dry run
-C dir	Change to dir before doing anything
-t tool	Run a sub-tool (clean, query, targets, graph, compdb)

4. Cleaning

ninja -t clean          # remove build outputs
ninja -t clean -g       # also remove generated files

Or via CMake:

cmake --build build --target clean

5. compile_commands.json

Ninja (via CMake) can generate a compile_commands.json for IDE integration and clang-tidy:

cmake -S . -B build -G Ninja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
ln -sf build/compile_commands.json .

6. build.ninja format (reference)

Rarely hand-written, but useful to understand for debugging:

# Variable
cflags = -Wall -O2

# Rule
rule cc
  command = gcc $cflags -c $in -o $out
  description = CC $in

# Build edge
build foo.o: cc foo.c

# Phony target
build all: phony foo.o

# Default target
default all

Key concepts:

• rule: defines how to produce outputs from inputs
• build: instantiates a rule with specific files
• $in / $out: automatic variables for inputs/outputs
• phony: a target that is always considered out of date (like .PHONY in make)

7. Ninja sub-tools

# List all build targets
ninja -t targets

# Query dependencies of a target
ninja -t query myapp

# Clean (already mentioned)
ninja -t clean

# Generate compile_commands.json (if supported by generator)
ninja -t compdb cc cxx > compile_commands.json

# List rules
ninja -t rules

8. Common issues

Issue	Cause	Fix
ninja: error: 'foo.o', needed by 'prog', missing and no known rule to make it	Missing build rule	Regenerate with CMake; check add_executable source list
Build not picking up changes	Stale build.ninja	Re-run cmake -S . -B build
Very slow parallel build	-j too high for I/O-bound build	Use -l$(nproc) to limit by load
Circular dependency	Rule depends on itself	Check CMake target dependencies

For the full Ninja command reference, build.ninja format details, and CMake integration patterns, see references/cheatsheet.md.

Related skills

• Use skills/build-systems/cmake for CMake configuration that generates Ninja files
• Use skills/build-systems/make for Make-based projects