How to Create a Makefile to Automate Repetitive Tasks

What a Makefile does and why you need one

A Makefile is a text file that tells your computer to run a series of commands in order, all at once, whenever you type a single command. Instead of typing ten separate lines every time you want to compile code, run tests, and clean up temporary files, you type one word: make. The Makefile reads your instructions and executes them in the order you specified.

Makefiles are most common in software development, but they work for any repetitive task on Windows, Mac, or Linux — backing up folders, resizing images in batch, organizing files, or running multiple programs in sequence. The real value appears when you do the same set of steps more than twice. After that, a Makefile saves time and prevents the mistakes that come from typing the same commands by hand.

A Makefile is plain text, costs nothing, and requires no special software beyond what your computer already has. You create it in any text editor, save it with the exact name Makefile (capital M, no extension), and place it in the folder where you want the work to happen.

Key Takeaways

A Makefile is a text file named exactly Makefile that lists commands to run in order when you type make at the command line.
Each task in a Makefile is called a target and starts with a name followed by a colon, with the commands indented underneath using a single Tab character (not spaces).
You create a Makefile in any text editor, save it in the folder where you want the work to happen, and run it by opening a terminal or command prompt in that same folder and typing make targetname.
The most common mistake is using spaces instead of Tab characters for indentation, which causes the Makefile to fail silently or with a cryptic error.
A Makefile can run commands in any language or program your computer has installed — shell commands, Python scripts, compilers, backup tools, or anything else you can type at the command line.

The basic structure of a Makefile

Every Makefile follows the same pattern. Each task is called a target and has three parts: a name, a colon, and the commands that run when you call that target. Here is the simplest possible Makefile:

clean: rm -f *.tmp rm -f *.log

The word clean is the target name. The two lines below it are the commands that run when you type make clean. Those commands delete all files ending in .tmp and .log. The critical detail: each command line must start with a single Tab character, not spaces. This is the single most common source of errors.

You can have multiple targets in one Makefile. Each one runs independently when you call it by name. Here is a Makefile with three targets:

build: gcc -o myprogram myprogram.c test: ./myprogram clean: rm -f myprogram

Now you can type make build to compile, make test to run the program, or make clean to delete it. Each target does one job. If you want to run all three in order, you create a target that depends on the others — that comes next.

Making targets run in sequence

Often you want one task to run only after another finishes. You do this by listing the other targets after the colon on the first line. Here is a Makefile that builds, tests, and cleans in order:

all: build test clean build: gcc -o myprogram myprogram.c test: ./myprogram clean: rm -f myprogram

Now make all runs build first, then test, then clean, in that order. The all target has no commands of its own — it just lists the other targets it depends on. This pattern is useful because you can still run make build by itself if you only want that step.

The order matters. If you list test before build, the test will run on the old version of the program, or fail if the program does not exist yet. Think through the logical order before you write the target list.

Creating your first Makefile

Open any text editor — Notepad on Windows, TextEdit on Mac, or gedit on Linux. Do not use a word processor like Microsoft Word; it adds invisible formatting that breaks Makefiles. Type your targets and commands, then save the file with the exact name Makefile in the folder where you want the work to happen. The name must start with a capital M and have no file extension like .txt.

Here is a practical example for someone who wants to back up a folder and then compress it:

backup: cp -r /home/user/documents /home/user/backup_documents compress: tar -czf backup_documents.tar.gz /home/user/backup_documents all: backup compress

Save this as Makefile in your home folder. Open a terminal or command prompt, navigate to that folder, and type make all. The computer will copy your documents folder, then compress the copy into a single file. Both steps run automatically.

If you are on Windows and do not have the cp and tar commands, use Windows equivalents like xcopy and powershell, or install Git Bash, which provides Unix-style commands on Windows.

Avoiding the Tab character mistake

The most frustrating error in Makefiles comes from using spaces instead of Tab characters for indentation. Your eyes cannot tell the difference, but the Makefile parser can. If you use spaces, you will see an error like "missing separator" or the commands will not run at all.

To avoid this: in your text editor, look for a setting that shows invisible characters or whitespace. In most editors, this is under View or Preferences. Turn it on so you can see whether each indented line starts with a Tab (shown as a long arrow or block) or spaces (shown as dots). Every command line must start with exactly one Tab.

If you are copying a Makefile from a website or another document, the spaces may have been converted during copy-paste. Delete the indentation and retype it using your Tab key. This is tedious but reliable. Some editors have a setting to convert all spaces to Tabs automatically — check your editor's documentation if you work with Makefiles often.

Running your Makefile from the command line

To run a Makefile, open a terminal or command prompt and navigate to the folder that contains it. On Windows, use Command Prompt or PowerShell. On Mac or Linux, use Terminal. Type cd followed by the path to your folder. For example:

cd /home/user/myproject

Then type make followed by the target name:

make all

If you have a target called all, you can also just type make with no target name — it will run the first target in the file by default. The computer will execute each command in order and print the output to the terminal. If a command fails, the Makefile stops and shows you the error.

To see all available targets without running anything, type make -n targetname. This shows you what would run without actually running it — useful for checking your work before you commit to it.

Common patterns and examples

Here is a Makefile for someone managing a Python project with tests and documentation:

install: pip install -r requirements.txt test: python -m pytest docs: python -m sphinx -b html docs docs/_build clean: rm -rf __pycache__ rm -rf .pytest_cache rm -rf docs/_build all: install test docs

This Makefile installs dependencies, runs tests, builds documentation, and cleans up temporary files. Each target can run alone, or make all runs them in order.

Here is a Makefile for image processing:

resize: mogrify -resize 800x600 *.jpg backup: cp -r . backup_$(date +%Y%m%d) all: backup resize

The backup target uses $(date +%Y%m%d) to add today's date to the folder name, so each backup has a unique name. The resize target uses mogrify (part of ImageMagick) to shrink all JPG files in the folder.

Frequently Asked Questions

Do I need to install anything to use a Makefile?

On Mac and Linux, make is already installed. On Windows, you need to install it separately — the easiest way is through Git Bash, which includes make along with other Unix tools. Alternatively, you can install Make for Windows directly from the GNU Make project website.

What if I want to run a Makefile from a different folder?

Use the -C flag to tell make which folder to look in. For example, make -C /path/to/folder all runs the Makefile in that folder without changing your current directory. This is useful in scripts that manage multiple projects.

Can I use variables in a Makefile?

Yes. Define a variable at the top with VARNAME = value, then use it in commands with $(VARNAME). For example, COMPILER = gcc at the top, then $(COMPILER) -o program program.c in a command. This makes it straightforward to change settings in one place instead of editing every command.

What happens if a command in a target fails?

The Makefile stops when ready and does not run the remaining commands in that target or any targets that depend on it. This is usually what you want — if compilation fails, there is no point running tests. If you want a target to keep going even when a command fails, prefix the command with a hyphen: -rm -f file.txt will not stop the Makefile if the file does not exist.

Can I run a Makefile automatically on a schedule?

Yes, using your operating system's scheduler. On Mac and Linux, use cron to run make at specific times. On Windows, use Task Scheduler. Both let you set up a job that runs a command at a time you choose — for example, every night at 2 AM to back up your files.

This guide is for general information only and is not medical, financial, legal, or other professional advice. For decisions specific to your situation, consult a qualified professional. See our Editorial Policy.