Why should I use scikit-build ?

Scikit-build is a replacement for distutils.core.Extension with the following advantages:

Basic Usage

Example of setup.py, CMakeLists.txt and pyproject.toml

The full example code is Here

Make a fold name my_project as your project root folder, place the following in your project’s setup.py file:

from skbuild import setup  # This line replaces 'from setuptools import setup'
setup(
    name="hello-cpp",
    version="1.2.3",
    description="a minimal example package (cpp version)",
    author='The scikit-build team',
    license="MIT",
    packages=['hello'],
    python_requires=">=3.7",
)

Your project now uses scikit-build instead of setuptools.

Next, add a CMakeLists.txt to describe how to build your extension. In the following example, a C++ extension named _hello is built:

cmake_minimum_required(VERSION 3.18...3.22)

project(hello)

find_package(PythonExtensions REQUIRED)

add_library(_hello MODULE hello/_hello.cxx)
python_extension_module(_hello)
install(TARGETS _hello LIBRARY DESTINATION hello)

Then, add a pyproject.toml to list the build system requirements:

[build-system]
requires = [
    "setuptools>=42",
    "scikit-build>=0.13",
    "cmake>=3.18",
    "ninja",
]
build-backend = "setuptools.build_meta"

Make a hello folder inside my_project folder and place _hello.cxx and __init__.py inside hello folder.

Now every thing is ready, go to my_project’s parent folder and type following command to install your extension:

pip install my_project/.

If you want to see the detail of installation:

pip install my_project/. -v

Try your new extension:

$ python
Python 3.10.4 (main, Jun 29 2022, 12:14:53) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import hello
>>> hello.hello("scikit-build")
Hello, scikit-build!
>>>

You can add lower limits to cmake or scikit-build as needed. Ninja should be limited to non-Windows systems, as MSVC 2017+ ships with Ninja already, and there are fall-backs if Ninja is missing, and the Python Ninja seems to be less likely to find MSVC than the built-in one currently.

Note

By default, scikit-build looks in the project top-level directory for a file named CMakeLists.txt. It will then invoke cmake executable specifying a generator matching the python being used.

Setup options

setuptools options

The section below documents some of the options accepted by the setup() function. These currently must be passed in your setup.py, not in setup.cfg, as scikit-build intercepts them and inspects them. This restriction may be relaxed in the future. Setuptools options not listed here can be placed in setup.cfg as normal.

  • packages: Explicitly list of all packages to include in the distribution. Setuptools will not recursively scan the source tree looking for any directory with an __init__.py file. To automatically generate the list of packages, see Using find_package().

  • package_dir: A mapping of package to directory names

  • include_package_data: If set to True, this tells setuptools to automatically include any data files it finds inside your package directories that are specified by your MANIFEST.in file. For more information, see the setuptools documentation section on Including Data Files. scikit-build matches the setuptools behavior of defaulting this parameter to True if a pyproject.toml file exists and contains either the project or tool.setuptools table.

  • package_data: A dictionary mapping package names to lists of glob patterns. For a complete description and examples, see the setuptools documentation section on Including Data Files. You do not need to use this option if you are using include_package_data, unless you need to add e.g. files that are generated by your setup script and build process. (And are therefore not in source control or are files that you don’t want to include in your source distribution.)

  • exclude_package_data: Dictionary mapping package names to lists of glob patterns that should be excluded from the package directories. You can use this to trim back any excess files included by include_package_data. For a complete description and examples, see the setuptools documentation section on Including Data Files.

  • py_modules: List all modules rather than listing packages. More details in the Listing individual modules section of the distutils documentation.

  • data_files: Sequence of (directory, files) pairs. Each (directory, files) pair in the sequence specifies the installation directory and the files to install there. More details in the Installing Additional Files section of the setuptools documentation.

  • entry_points: A dictionary mapping entry point group names to strings or lists of strings defining the entry points. Entry points are used to support dynamic discovery of services or plugins provided by a project. See Dynamic Discovery of Services and Plugins for details and examples of the format of this argument. In addition, this keyword is used to support Automatic Script Creation. Note that if using pyproject.toml for configuration, the requirement to put entry_points in setup.py also requires that the project section include entry_points in the dynamic section.

  • scripts: List of python script relative paths. If the first line of the script starts with #! and contains the word python, the Distutils will adjust the first line to refer to the current interpreter location. More details in the Installing Scripts section of the distutils documentation.

Added in version 0.8.0.

  • zip_safe: A boolean indicating if the Python packages may be run directly from a zip file. If not already set, scikit-build sets this option to False. See Setting the zip_safe flag section of the setuptools documentation.

Note

As specified in the Wheel documentation, the universal and python-tag options have no effect.

scikit-build options

Scikit-build augments the setup() function with the following options:

For example:

setup(
  [...]
  cmake_args=['-DSOME_FEATURE:BOOL=OFF']
  [...]
  )

  • cmake_install_dir: relative directory where the CMake artifacts are installed. By default, it is set to an empty string.

  • cmake_source_dir: Relative directory containing the project CMakeLists.txt. By default, it is set to the top-level directory where setup.py is found.

  • cmake_process_manifest_hook: Python function consuming the list of files to be installed produced by cmake. For example, cmake_process_manifest_hook can be used to exclude static libraries from the built wheel.

For example:

def exclude_static_libraries(cmake_manifest):
    return list(filter(lambda name: not (name.endswith('.a')), cmake_manifest))

setup(
  [...]
  cmake_process_manifest_hook=exclude_static_libraries
  [...]
)

Added in version 0.5.0.

  • cmake_with_sdist: Boolean indicating if CMake should be executed when running sdist command. Setting this option to True is useful when part of the sources specified in MANIFEST.in are downloaded by CMake. By default, this option is False.

Added in version 0.7.0.

  • cmake_languages: Tuple of languages that the project use, by default ('C', 'CXX',). This option ensures that a generator is chosen that supports all languages for the project.

  • cmake_minimum_required_version: String identifying the minimum version of CMake required to configure the project.

  • cmake_install_target: Name of the target to “build” for installing the artifacts into the wheel. By default, this option is set to install, which is always provided by CMake. This can be used to only install certain components.

For example:

install(TARGETS foo COMPONENT runtime)
add_custom_target(foo-install-runtime
    ${CMAKE_COMMAND}
    -DCMAKE_INSTALL_COMPONENT=runtime
    -P "${PROJECT_BINARY_DIR}/cmake_install.cmake"
    DEPENDS foo
    )

Scikit-build changes the following options:

Added in version 0.7.0.

  • setup_requires: If cmake is found in the list, it is explicitly installed first by scikit-build.

Command line options

Warning: Passing options to setup.py is deprecated and may be removed in a future release. Environment variables can be used instead for most options.

usage: setup.py [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...] [skbuild_opts] [cmake_configure_opts] [-- [cmake_opts] [-- [build_tool_opts]]]
or: setup.py --help [cmd1 cmd2 ...]
or: setup.py --help-commands
or: setup.py cmd --help

There are few types of options:

setuptools, scikit-build and CMake configure options can be passed normally, the cmake and build_tool set of options needs to be separated by --:

Arguments following a "--" are passed directly to CMake (e.g. -DSOME_FEATURE:BOOL=ON).
Arguments following a second "--" are passed directly to  the build tool.

setuptools options

For more details, see the official documentation.

scikit-build extends the global set of setuptools options with:

Added in version 0.4.0.

Global options:
  [...]
  --hide-listing      do not display list of files being included in the
                      distribution

Added in version 0.5.0.

Global options:
  [...]
  --force-cmake       always run CMake
  --skip-cmake        do not run CMake

Note

As specified in the Wheel documentation, the --universal and --python-tag options have no effect.

scikit-build options

scikit-build options:
  --build-type       specify the CMake build type (e.g. Debug or Release)
  -G , --generator   specify the CMake build system generator
  -j N               allow N build jobs at once
  [...]

Added in version 0.7.0.

scikit-build options:
  [...]
  --cmake-executable specify the path to the cmake executable

Added in version 0.8.0.

scikit-build options:
  [...]
  --skip-generator-test  skip generator test when a generator is explicitly selected using --generator

CMake Configure options

Added in version 0.10.1.

These options are relevant when configuring a project and can be passed as global options using setup.py or pip install.

The CMake options accepted as global options are any of the following:

-C<initial-cache>            = Pre-load a script to populate the cache.
-D<var>[:<type>]=<value>     = Create or update a cmake cache entry.

Warning

The CMake configure option should be passed without spaces. For example, use -DSOME_FEATURE:BOOL=ON instead of -D SOME_FEATURE:BOOL=ON.

CMake options

These are any specific to CMake. See list of CMake options.

For example:

-DSOME_FEATURE:BOOL=OFF

build tool options

These are specific to the underlying build tool (e.g msbuild.exe, make, ninja).

Advanced Usage

How to test if scikit-build is driving the compilation ?

To support the case of code base being built as both a standalone project and a python wheel, it is possible to test for the variable SKBUILD:

if(SKBUILD)
  message(STATUS "The project is built using scikit-build")
endif()

Adding cmake as building requirement only if not installed or too low a version

If systematically installing cmake wheel is not desired, it is possible to set it using an in-tree backend. For this purpose place the following configuration in your pyproject.toml:

[build-system]
requires = [
  "setuptools>=42",
  "packaging",
  "scikit-build",
  "ninja; platform_system!='Windows'"
]
build-backend = "backend"
backend-path = ["_custom_build"]

then you can implement a thin wrapper around build_meta in the _custom_build/backend.py file:

from setuptools import build_meta as _orig

prepare_metadata_for_build_wheel = _orig.prepare_metadata_for_build_wheel
build_wheel = _orig.build_wheel
build_sdist = _orig.build_sdist
get_requires_for_build_sdist = _orig.get_requires_for_build_sdist

def get_requires_for_build_wheel(config_settings=None):
    from packaging import version
    from skbuild.exceptions import SKBuildError
    from skbuild.cmaker import get_cmake_version
    packages = []
    try:
        if version.parse(get_cmake_version()) < version.parse("3.4"):
            packages.append('cmake')
    except SKBuildError:
        packages.append('cmake')

    return _orig.get_requires_for_build_wheel(config_settings) + packages

Also see scikit-build-core where this is a built-in feature.

Enabling parallel build

Ninja

If Ninja generator is used, the associated build tool (called ninja) will automatically parallelize the build based on the number of available CPUs.

To limit the number of parallel jobs, the build tool option -j N can be passed to ninja.

For example, to limit the number of parallel jobs to 3, the following could be done:

python setup.py bdist_wheel -- -- -j3

For complex projects where more granularity is required, it is also possible to limit the number of simultaneous link jobs, or compile jobs, or both.

Indeed, starting with CMake 3.11, it is possible to configure the project with these options:

For example, to have at most 5 compile jobs and 2 link jobs, the following could be done:

python setup.py bdist_wheel -- \
  -DCMAKE_JOB_POOL_COMPILE:STRING=compile \
  -DCMAKE_JOB_POOL_LINK:STRING=link \
  '-DCMAKE_JOB_POOLS:STRING=compile=5;link=2'

Unix Makefiles

If Unix Makefiles generator is used, the associated build tool (called make) will NOT automatically parallelize the build, the user has to explicitly pass option like -j N.

For example, to limit the number of parallel jobs to 3, the following could be done:

python setup.py bdist_wheel -- -- -j3

Visual Studio IDE

If Visual Studio IDE generator is used, there are two types of parallelism:

  • target level parallelism

  • object level parallelism

Warning

Since finding the right combination of parallelism can be challenging, whenever possible we recommend to use the Ninja generator.

To adjust the object level parallelism, the compiler flag /MP[processMax] could be specified. To learn more, read /MP (Build with Multiple Processes).

For example:

set CXXFLAGS=/MP4
python setup.py bdist_wheel

The target level parallelism can be set from command line using /maxcpucount:N. This defines the number of simultaneous MSBuild.exe processes. To learn more, read Building Multiple Projects in Parallel with MSBuild.

For example:

python setup.py bdist_wheel -- -- /maxcpucount:4

Support for isolated build

Added in version 0.8.0.

As specified in PEP 518, dependencies required at install time can be specified using a pyproject.toml file. Starting with pip 10.0, pip reads the pyproject.toml file and installs the associated dependencies in an isolated environment. See the pip build system interface documentation.

An isolated environment will be created when using pip to install packages directly from source or to create an editable installation.

scikit-build supports these use cases as well as the case where the isolated environment support is explicitly disabled using the pip option --no-build-isolation available with the install, download and wheel commands.

Optimized incremental build

To optimize the developer workflow, scikit-build reconfigures the CMake project only when needed. It caches the environment associated with the generator as well as the CMake execution properties.

The CMake properties are saved in a CMake spec file responsible to store the CMake executable path, the CMake configuration arguments, the CMake version as well as the environment variables PYTHONNOUSERSITE and PYTHONPATH.

If there are no CMakeCache.txt file or if any of the CMake properties changes, scikit-build will explicitly reconfigure the project calling skbuild.cmaker.CMaker.configure().

If a file is added to the CMake build system by updating one of the CMakeLists.txt file, scikit-build will not explicitly reconfigure the project. Instead, the generated build-system will automatically detect the change and reconfigure the project after skbuild.cmaker.CMaker.make() is called.

Environment variable configuration

Scikit-build support environment variables to configure some options. These are:

SKBUILD_CONFIGURE_OPTIONS/CMAKE_ARGS

This will add configuration options when configuring CMake. SKBUILD_CONFIGURE_OPTIONS will be used instead of CMAKE_ARGS if both are defined.

SKBUILD_BUILD_OPTIONS

Pass options to the build.

Cross-compilation

See CMake Toolchains.

Introduction to dockross

Note

To be documented. See #227.

Using dockcross-manylinux to generate Linux wheels

Note

To be documented. See #227.

Using dockcross-mingwpy to generate Windows wheels

Note

To be documented. See #227.

Examples for scikit-build developers

Note

To be documented. See #227.

Provide small, self-contained setup function calls for (at least) two use cases:

  • when a CMakeLists.txt file already exists

  • when a user wants scikit-build to create a CMakeLists.txt file based on the user specifying some input files.