Chapter 2: Setting Up Your Environment

This chapter gets a working C toolchain on your machine, shows how to compile from the command line, introduces small Makefile builds, and points to editor and IDE choices that fit a portable workflow.

Installing GCC on Linux, macOS, and Windows

GCC is available on all major platforms. Install it with the native package manager on Linux, with Apple’s command line tools or Homebrew on macOS, and with MSYS2 or MinGW on Windows. After installation, verify with gcc --version.

Installing under Linux

Here is how to install under some top flavors of Linux:

Installing under macOS

Using macOS install like this:

# Apple Command Line Tools (provides Clang; often enough)
xcode-select --install

# Optional: Homebrew GCC alongside Clang
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install gcc

After installing, run gcc --version. On macOS the default gcc is usually Clang’s driver for compatibility. Installing Homebrew gcc gives you a GNU build as well (named gcc-… such as gcc-14).

Installing under Windows

Following are the various Windows installation options:

Using the command line to compile and run programs

The compiler driver handles preprocessing, compiling, and linking. Start with a single-file program, then add warnings and standard selection. Keep commands simple and repeatable.

A single-file build

A single-file build looks like tyis:

# GCC
gcc -std=c23 -Wall -Wextra -O2 hello.c -o hello

# Clang
clang -std=c23 -Wall -Wextra -O2 hello.c -o hello

# Run (Unix-like)
./hello

# Run (Windows)
hello.exe

Use -std=c23 for a modern baseline. Enable warnings with -Wall -Wextra. Add -g for debug symbols when needed.

Separating compiling and linking

This is how you separate compiling and linking:

# Compile to objects
gcc -std=c23 -Wall -Wextra -O2 -c util.c -o util.o
gcc -std=c23 -Wall -Wextra -O2 -c main.c -o main.o

# Link objects into an executable
gcc util.o main.o -o app

Compiling to objects avoids rebuilding every file. The linker step produces the final program.

Using Makefiles for simple builds

make automates rebuilds based on file timestamps. A small Makefile turns multi-file commands into named targets. Variables keep flags in one place.

A minimal portable Makefile

An example Makefile might look like this:

# file: Makefile
CC    := gcc
CFLAGS  := -std=c23 -Wall -Wextra -O2
LDFLAGS :=
TARGET  := app
SRCS  := main.c util.c
OBJS  := $(SRCS:.c=.o)

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

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

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

clean:
	$(RM) $(OBJS) $(TARGET)

Tabs are required before recipe lines. The pattern rule builds any .o from a matching .c. The run target executes the program on Unix-like systems.

Using Windows

With MSYS2 or Git Bash, the above Makefile works as written. On native Windows shells you may use mingw32-make instead of make, and replace the run recipe with a line that invokes $(TARGET).exe.

Working with IDEs and editors

Choose an editor that respects your command-line workflow. You can keep gcc, clang, and make at the core, while the editor provides IntelliSense, code navigation, and debugging.

Using VS Code

Install the C/C++ extension. Use a simple tasks.json to call your Makefile or compiler directly. For cross-platform projects, pair VS Code with CMake Tools to configure and build out of source.

Using CLion

CLion uses CMake as the project model. You write a CMakeLists.txt, then build and debug with the integrated toolchains. CLion can target WSL, MinGW, or remote toolchains.

Other solid choices

A list of other popular options: