Makefile Generator

Generate a Makefile for C, C++, Python, Node.js, or Go projects with common targets: build, test, clean, run, and install.

Presets:

Compiler / Env

gcc

Source Folder

src

Total Targets

4 targets

Makefile Size

28 lines (429 B)

Language

Project Name

Source Directory

Output Binary Name

Makefile

CC = gcc
CFLAGS = -Wall -Wextra -O2
SRC_DIR = src
BUILD_DIR = build
TARGET = myapp

SRCS = $(wildcard $(SRC_DIR)/*.c)
OBJS = $(SRCS:$(SRC_DIR)/%.c=$(BUILD_DIR)/%.o)

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CC) $(OBJS) -o $(TARGET)

$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
	@mkdir -p $(BUILD_DIR)
	$(CC) $(CFLAGS) -c $< -o $@

run: $(TARGET)
	./$(TARGET)

clean:
	rm -rf $(BUILD_DIR) $(TARGET)

test:
	./test.sh

.PHONY: all run clean test

About the Makefile Generator

A Makefile automates common development tasks like building, testing, and cleaning your project. This generator creates language-specific Makefiles with sensible defaults: C and C++ projects get compiler flags and object file handling, Python projects get pytest and flake8 targets, Node.js gets npm script wrappers, Go usesgo build andgo test, and Rust wraps Cargo commands. Tabs in Makefiles are significant — copy as-is to preserve them.

Built and maintained by Meet Shah · Last updated 18 July 2026

What this tool is used for

Producing a Makefile with the standard targets for a language.
Getting the tab-indentation right, which is the one thing Make insists on.
Producing a starting file you then extend with project-specific targets.
Standardising target names across several repositories.
Getting a build and test entry point for a project that has none.

Frequently Asked Questions

Why does a Makefile need tabs?: Because a recipe line is identified by a literal tab character — spaces produce the error "missing separator". It is the most famous wart in the format, kept for four decades of backward compatibility, and it is why pasting a Makefile through an editor that expands tabs breaks it.
What is a .PHONY target?: A declaration that a target name is not a file. Without it, a target called `clean` stops working the moment a file named `clean` exists in the directory — make sees the file, decides it is up to date, and does nothing. `.PHONY` tells it to always run the recipe.
Why use make rather than a shell script?: Dependencies and incremental builds. Make compares timestamps and only rebuilds what changed, and `make -j8` parallelises independent targets automatically from the dependency graph. A shell script runs everything, every time, in the order you wrote it.
What is the difference between = and := ?: `=` is recursively expanded — the right-hand side is re-evaluated every time the variable is used, so it can reference variables defined later. `:=` expands once, immediately. Prefer `:=` unless you specifically need the deferred behaviour; it is faster and far easier to reason about.
Does each recipe line run in the same shell?: No — each line gets its own shell process, which is why `cd build` on one line has no effect on the next. Join them with `&&` and a line continuation, or set `.ONESHELL:` to run the whole recipe in one shell.

Common errors and gotchas

Indenting a recipe with spaces, which Make rejects — recipes require a tab.
Omitting `.PHONY`, so a target stops running once a file of the same name exists.
Assuming each recipe line shares a shell, when Make runs each in its own by default.
Relying on a variable expanded at the wrong time, since `=` and `:=` differ.
Writing a target whose dependencies are wrong, so it does not rebuild when it should.