pcons

Build anything. Effortlessly.

A modern, cross-platform, zero-install build system. Describe your builds in real Python. Generate Ninja files. Build fast.

PyPI version Python versions CI Docs
Read the Docs View on GitHub
$ uvx pcons

Why pcons?

Inspired by SCons and CMake, taking the best ideas from each.

Python is the language

No custom DSL to learn. Your build scripts are real Python with full IDE support, debugging, type checking, and the entire ecosystem at your fingertips.

Zero install

Run with uvx pcons — no installation required beyond uv. No daemon, no workspace lock files, no registry setup.

Fast configures and fast builds

Pcons generates Ninja build files and lets Ninja handle execution — one pcons command generates and builds. Fast, parallel builds with minimal overhead. Also supports Makefile and Xcode output. Pcons is typically significantly faster to configure than cmake (4-13x in my tests).

Transitive dependencies

Like CMake's usage requirements: include directories, link flags, and defines propagate automatically through your dependency graph.

Cross-platform

First-class support for Linux, macOS, and Windows. GCC, Clang, MSVC, Clang-CL, plus cross-compilation for Android, iOS, and WebAssembly.

Tool-agnostic core

The core knows nothing about compilers or languages. All tool-specific logic lives in pluggable toolchains. Build C++, Fortran, CUDA, Cython, Metal shaders, or anything else.

Simple and expressive

Real build scripts from the pcons examples.

pcons-build.py — Hello World
from pcons import Project

project = Project("hello")
env = project.Environment(toolchain="c")

project.Program("hello", env, sources=["src/hello.c"])
pcons-build.py — Libraries + Transitive Deps
from pcons import Project

project = Project("myapp")
env = project.Environment(toolchain="c")

# Build a static library
lib = project.StaticLibrary("core", env, sources=["src/core.c"])
lib.public.include_dirs.append("include")

# Program links the library — includes propagate
app = project.Program("myapp", env, sources=["src/main.c"])
app.link(lib)
Terminal
$ uvx pcons
ninja: Entering directory `build'
[1/4] CC obj.core/src/core.c.o
[2/4] CC obj.myapp/src/main.c.o
[3/4] AR libcore.a
[4/4] LINK myapp

Built-in support

Toolchains, generators, and packages — all pluggable and extensible.

GCC Clang / LLVM MSVC Clang-CL CUDA Cython Fortran Swift Rust (via Cargo) WASI Emscripten Metal

Generators

Ninja (default), Makefile, Xcode, compile_commands.json, and Mermaid or Graphviz dependency diagrams.

Package management

Integrates with pkg-config, Conan, and vcpkg. The pcons-fetch tool builds dependencies from source.

Configure-time checks

check_header(), check_flag(), try_compile(), configure_file() with CMake-style template substitution. Results are cached.

C++20 modules

Named modules, partitions, and import std with automatic dependency scanning — on GCC, Clang, and MSVC.

Installers

Generate native installers from your build script: signed and notarized .pkg and .dmg on macOS, MSIX packages on Windows.

Test runner

Declare tests with project.Test(), run them with pcons test — labels, timeouts, gtest/doctest/Catch2 case discovery, and fuzzing support.

How it compares

pcons sits between Meson's ergonomics and Bazel's extensibility.

Feature pcons CMake Meson Bazel
Config language Python 3.11+ CMake DSL Custom DSL Starlark
Execution model Generates Ninja/Make/Xcode Generates Ninja/Make Generates Ninja/VS/Xcode Executes directly
Transitive deps Yes Yes Limited Yes
IDE support compile_commands.json compile_commands.json compile_commands.json External tools
Windows support Excellent Excellent Excellent Fair
Setup overhead uvx pcons Install CMake + generator pip/brew + Ninja Bazel + workspace setup
Learning curve Low (it's Python) High Low-Medium High
Extensibility Plugin registry CMake modules Limited Custom Starlark rules
Debuggability Full Python debugger message() / cmake --trace Print statements bazel query

Why I built pcons

I was one of the original developers of SCons, and helped maintain it for many years. I love that Python is the config language — it makes build descriptions incredibly flexible and powerful. More recently I've used CMake on larger projects, and despite the painful configuration language I came to appreciate its strengths: dependency propagation, package integration, and the clean separation between describing a build and running it.

For years I'd been thinking about rebuilding those ideas on a modern Python stack — fixing the long-standing pain points around substitution and quoting, extensibility, and tracing along the way. Pcons is that project.

Pcons is developed with care and extensively tested on Linux, macOS, and Windows — unit, end-to-end, and example tests on every platform, every commit. As a professional software engineer with 40+ years of serious C/C++/Python experience, I stand behind it and intend to support it long-term.

— Gary Oberbrunner

Ready for small-scale production use

pcons is working in several medium-sized projects, and still under active development. C, C++ (including C++20 modules), Fortran, and Swift compilation, static and shared libraries, programs, install targets, installers, unit tests, and mixed-language builds are all tested and working across Linux, macOS, and Windows.

Get Started Contribute on GitHub