glob[str],
language listify[str]:,
native bool:,

The compiler arguments to add

Specifies the language(s) that the arguments should be applied to. If an array of languages is given, the arguments are added to each of the corresponding compiler command lines. Note that there is no way to remove an argument set in this way. If you have an argument that is only used in a subset of targets, you have to specify it in per-target flags.

A boolean specifying whether the arguments should be applied to the native or cross compilation. If true the arguments will only be used for native compilations. If false the arguments will only be used in cross compilations. If omitted, the flags are added to native compilations if compiling natively and cross compilations (only) when cross compiling.

glob[str],
language listify[str]:,
native bool:,

The linker arguments to add

Specifies the language(s) that the arguments should be applied to. If an array of languages is given, the arguments are added to each of the corresponding compiler command lines. Note that there is no way to remove an argument set in this way. If you have an argument that is only used in a subset of targets, you have to specify it in per-target flags.

A boolean specifying whether the arguments should be applied to the native or cross compilation. If true the arguments will only be used for native compilations. If false the arguments will only be used in cross compilations. If omitted, the flags are added to native compilations if compiling natively and cross compilations (only) when cross compiling.

glob[str],
native bool:,
required bool|feature:,
toolchain compiler:,

The languages to add

If set to true, the language will be used to compile for the build machine, if false, for the host machine.

If set to true, Meson will halt if any of the languages specified are not found. (since 0.47.0) The value of a [feature] option can also be passed.

Instead of detecting a toolchain, use the compiler toolchain for this language.

glob[str],
language listify[str]:,
native bool:,

The compiler arguments to add

Specifies the language(s) that the arguments should be applied to. If an array of languages is given, the arguments are added to each of the corresponding compiler command lines. Note that there is no way to remove an argument set in this way. If you have an argument that is only used in a subset of targets, you have to specify it in per-target flags.

A boolean specifying whether the arguments should be applied to the native or cross compilation. If true the arguments will only be used for native compilations. If false the arguments will only be used in cross compilations. If omitted, the flags are added to native compilations if compiling natively and cross compilations (only) when cross compiling.

glob[dep],
language listify[str]:,
native bool:,

The dependencies to add; if internal dependencies are included, they must not include any built object.

Specifies the language(s) that the arguments should be applied to. If an array of languages is given, the arguments are added to each of the corresponding compiler command lines. Note that there is no way to remove an argument set in this way. If you have an argument that is only used in a subset of targets, you have to specify it in per-target flags.

A boolean specifying whether the arguments should be applied to the native or cross compilation. If true the arguments will only be used for native compilations. If false the arguments will only be used in cross compilations. If omitted, the flags are added to native compilations if compiling natively and cross compilations (only) when cross compiling.

glob[str],
language listify[str]:,
native bool:,

The linker arguments to add

Specifies the language(s) that the arguments should be applied to. If an array of languages is given, the arguments are added to each of the corresponding compiler command lines. Note that there is no way to remove an argument set in this way. If you have an argument that is only used in a subset of targets, you have to specify it in per-target flags.

A boolean specifying whether the arguments should be applied to the native or cross compilation. If true the arguments will only be used for native compilations. If false the arguments will only be used in cross compilations. If omitted, the flags are added to native compilations if compiling natively and cross compilations (only) when cross compiling.

str,
env dict[listify[str]]|env|listify[str]:,
exclude_suites listify[str]:,
exe_wrapper listify[exe]:,
gdb bool:,
is_default bool:,
timeout_multiplier int:,

The name of the test setup

environment variables to set , such as ['NAME1=value1', 'NAME2=value2'], or an [@env] object which allows more sophisticated environment juggling. (Since 0.52.0) A dictionary is also accepted.

An array of test suites that should be excluded when using this setup. Suites specified in the --suite option to meson test will always run, overriding add_test_setup if necessary.

The command or script followed by the arguments to it

If true, the tests are also run under gdb

Set whether this is the default test setup. If true, the setup will be used whenever meson test is run without the --setup option.

A number to multiply the test timeout with. Since 0.57 if timeoutmultiplier is <= 0 the test has infinite duration, in previous versions of Meson the test would fail with a timeout immediately.

str,
glob[alias_tgt|both_libs|build_tgt|custom_tgt],

The name of the alias target

The targets to depend on

bool,
str,

Abort if this evaluates to false

The error message to print.

str,
build_tgt|custom_tgt|external_program|file|python_installation,
args listify[exe]:,
depends listify[both_libs|build_tgt|custom_tgt|file]:,
env dict[listify[str]]|env|listify[str]:,
expected_exitcode int:,
expected_fail bool:,
priority int:,
protocol str:,
should_fail bool:,
suite listify[str]:,
timeout int:,
workdir str:,

The unique test id

The program to execute. (Since 1.4.0) A CustomTarget is also accepted.

Arguments to pass to the executable

specifies that this test depends on the specified target(s), even though it does not take any of them as a command line argument. This is meant for cases where test finds those targets internally, e.g. plugins or globbing. Those targets are built before test is executed even if they have build_by_default : false.

environment variables to set, such as ['NAME1=value1', 'NAME2=value2'], or an [@env] object which allows more sophisticated environment juggling. (Since 0.52.0) A dictionary is also accepted.

the test is considered passed if the executable returns the specified returncode, only has effect when protocol is set to exitcode

when true the test is considered passed if the executable returns a non-zero return value (i.e. reports an error)

specifies the priority of a test. Tests with a higher priority are started before tests with a lower priority. The starting order of tests with identical priorities is implementation-defined. The default priority is 0, negative numbers are permitted.

specifies how the test results are parsed and can be one of exitcode, tap, or gtest. For more information about test harness protocol read [Unit Tests]. The following values are accepted:

• exitcode: the executable's exit code is used by the test harness to record the outcome of the test).
• tap: [Test Anything Protocol].
• gtest (since 0.55.0): for Google Tests.
• rust (since 0.56.0): for native rust tests

when true the test is considered passed if the executable returns a non-zero return value (i.e. reports an error)

the amount of seconds the test is allowed to run, a test that exceeds its time limit is always considered failed, defaults to 30 seconds. Since 0.57 if timeout is <= 0 the test has infinite duration, in previous versions of Meson the test would fail with a timeout immediately.

absolute path that will be used as the working directory for the test

glob[both_libs|build_tgt|custom_tgt|file|generated_list|str],
android_exe_type str:,
<lang>_args listify[str]:,
<lang>_pch build_tgt|file|list|str:,
<lang>_shared_args listify[str]:,
<lang>_static_args listify[str]:,
build_by_default bool:,
build_rpath str:,
build_subdir str:,
darwin_versions listify[int|str]:,
dependencies listify[dep]:,
export_dynamic bool:,
extra_files listify[both_libs|build_tgt|custom_tgt|file|str]:,
gnu_symbol_visibility str:,
gui_app bool:,
implib bool|str:,
implicit_include_directories bool:,
include_directories listify[inc|str]:,
install bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_rpath str:,
install_tag str:,
install_vala_gir bool|str:,
install_vala_header bool|str:,
install_vala_vapi bool|str:,
link_args listify[str]:,
link_depends listify[build_tgt|custom_tgt|file|str]:,
link_early_args listify[str]:,
link_language str:,
link_whole listify[both_libs|build_tgt|custom_tgt|file]:,
link_with listify[both_libs|build_tgt|custom_tgt|file]:,
name_prefix list|str:,
name_suffix list|str:,
native bool:,
objects listify[file|str]:,
override_options dict[bool|int|list|str]|list[str]|str:,
pic bool:,
pie bool:,
shortname str:,
sources listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
soversion int|str:,
target_type str:,
version str:,
vs_module_defs custom_tgt|file|str:,
win_subsystem str:,

The name for this build target, followed by an optional list of sources.

Specifies the intended target of the executable. This can either be executable, if the intended usecase is to run the executable using fork + exec, or application if the executable is supposed to be loaded as shared object by the android runtime.

compiler flags to use for the given language; eg: cpp_args for C++

precompiled header file to use for the given language

Arguments that are only passed to a shared library

Arguments that are only passed to a static library

Causes, when set to true, to have this target be built by default. This means it will be built when meson compile is called without any arguments. The default value is true for all built target types.

A string to add to target's rpath definition in the build dir, but which will be removed on install

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

Defines the compatibility version and current version for the dylib on macOS. If an array is specified, it must be either zero, one, or two elements. If only one element is specified or if it's not an array the specified value will be used for setting both compatibility version and current version. If unspecified, the soversion will be used as per the aforementioned rules.

one or more dependency objects created with [dependency] or [compiler.findlibrary] (for external deps) or [declaredependency] (for deps built by the project)

when set to true causes the target's symbols to be dynamically exported, allowing modules built using the [sharedmodule] function to refer to functions, variables and other symbols defined in the executable itself.

Not used for the build itself but are shown as source files in IDEs that group files by targets (such as Visual Studio).

These may only be static sources.

Specifies how symbols should be exported, see e.g [the GCC Wiki] for more information. This value can either be an empty string or one of default, internal, hidden, protected or inlineshidden, which is the same as hidden but also includes things like C++ implicit constructors as specified in the GCC manual. Ignored on compilers that do not support GNU visibility arguments. See also [snippets.symbol_visibility_header()] method to help with defining public API.

When set to true flags this target as a GUI application on platforms where this makes a difference, deprecated since 0.56.0, use win_subsystem instead.

When set to a string, that will be the name of a generated import library.

Since 1.10.0 passing a boolean value is deprecated.

When set to true, an import library is generated for the executable (the name of the import library is based on exename). Alternatively, when set to a string, that gives the base name for the import library. The import library is used when the returned build target object appears in link_with: elsewhere. Only has any effect on platforms where that is meaningful (e.g. Windows). Implies the export_dynamic argument.

Controls whether Meson adds the current source and build directories to the include path

one or more objects created with the [includedirectories] function, or (since 0.50.0) strings, which will be transparently expanded to include directory objects

When set to true, all outputs of this buildtarget will be installed.

override install directory for outputs of this build target. If the value is a relative path, it will be considered relative the prefix option. For example, if you want to install plugins into a subdir, you'd use something like this: install_dir : get_option('libdir') / 'projectname-1.0'.

This can be set to an array of values to control the the installation path of build targets with multiple outputs. Currently, that means Vala. Setting them to true means "use the default", and false means, don't install. By default the first element is true, and all other elements are false.

Since 1.11.0 Passing an array is deprecated, and installvalaheader, installvalavapi, and installvalagir keyword arguments should be used instead.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string to set the target's rpath to after install (but not before that). On Windows, this argument has no effect.

A string used by the meson install --tags command to install only a subset of the files. By default all build targets have the tag runtime except for static libraries that have the devel tag.

If set to a string value, the vala generated gir library will be installed to that path, if set to true, the default gir path will be used, if false the gir library will not be installed.

It is an error for this to be either true or a string and vala_gir to be unset.

The default value is false.

If set to a string value, the vala generated header will be installed to that path, if set to true, the default include path will be used, if false the header will not be installed.

The default value is false.

If set to a string value, the vala generated vapi library will be installed to that path, if set to true, the default vapi path will be used, if false the vapi library will not be installed.

The default value is false.

Flags to use during linking. You can use UNIX-style flags here for all platforms.

Strings, files, or custom targets the link step depends on such as a symbol visibility map. The purpose is to automatically trigger a re-link (but not a re-compile) of the target when this file changes.

Flags to use during linking. These are just like linkargs, except that they are inserted into the linker command line before any object files or libraries. You can use UNIX-style flags here for all platforms. This is only supported when using the Ninja backend.

Makes the linker for this target be for the specified language. It is generally unnecessary to set this, as Meson will detect the right linker to use in most cases. There are only two cases where this is needed. One, your main function in an executable is not in the language Meson picked, or second you want to force a library to use only one ABI.

(broken until 0.55.0)

Links all contents of the given static libraries whether they are used or not, equivalent to the -Wl,--whole-archive argument flag of GCC, or the '/WHOLEARCHIVE' MSVC linker option. This allows the linked target to re-export symbols from all objects in the static libraries.

(since 0.41.0) If passed an array that array will be flattened.

(since 0.51.0) This argument also accepts outputs produced by custom targets. The user must ensure that the output is a library in the correct format.

One or more shared or static libraries (built by this project) that this target should be linked with. (since 0.41.0) If passed an array that array will be flattened. (since 0.51.0) The arguments can also be custom targets. In this case Meson will assume that merely adding the output file in the linker command line is sufficient to make linking work. If this is not sufficient, then the build system writer must write all other steps manually.

The string that will be used as the prefix for the target output filename by overriding the default (only used for libraries). By default this is lib on all platforms and compilers, except for MSVC shared libraries where it is omitted to follow convention, and Cygwin shared libraries where it is cyg.

Set this to [], or omit the keyword argument for the default behaviour.

The string that will be used as the extension for the target by overriding the default. By default on Windows this is exe for executables and on other platforms it is omitted.

For shared libraries, the default value is dylib on macOS, dll on Windows, and so everywhere else. For static libraries, it is a everywhere. By convention MSVC static libraries use the lib suffix, but we use a to avoid a potential name clash with shared libraries which also generate import libraries with a lib suffix.

Set this to [], or omit the keyword argument for the default behaviour.

Controls whether the target is compiled for the build or host machines.

List of object files that should be linked in this target.

Since 1.1.0 this can include generated files in addition to object files that you don't have source to or that object files produced by other build targets. In earlier release, generated object files had to be placed in sources.

takes an array of strings in the same format as project's default_options overriding the values of these options for this target only. (since 1.2.0): A dictionary may now be passed.

Builds the library as positional independent code (so it can be linked into a shared library). This option has no effect on Windows and OS X since it doesn't make sense on Windows and PIC cannot be disabled on OS X.

Build a position-independent executable.

A string specifying a DLL name fitting to 8.3 limit on OS/2 of this shared library.

Additional source files. Same as the source varargs.

A string or integer specifying the soversion of this shared library, such as 0. On Linux and Windows this is used to set the soversion (or equivalent) in the filename. For example, if soversion is 4, a Windows DLL will be called foo-4.dll and one of the aliases of the Linux shared library would be libfoo.so.4. If this is not specified, the first part of version is used instead (see below). For example, if version is 3.6.0 and soversion is not defined, it is set to 3.

The actual target type to build

A string specifying the version of this shared library, such as 1.1.0. On Linux and OS X, this is used to set the shared library version in the filename, such as libfoo.so.1.1.0 and libfoo.1.1.0.dylib. If this is not specified, soversion is used instead (see above).

Specify a Microsoft module definition file for controlling symbol exports, etc., on platforms where that is possible (e.g. Windows).

(Since 1.3.0) [@customidx] are supported

Specifies the subsystem type to use on the Windows platform. Typical values include console for text mode programs and windows for gui apps. The value can also contain version specification such as windows,6.0. See [MSDN documentation] for the full list.

glob[both_libs|build_tgt|custom_tgt|file|generated_list|str],
android_exe_type str:,
<lang>_args listify[str]:,
<lang>_pch build_tgt|file|list|str:,
<lang>_shared_args listify[str]:,
<lang>_static_args listify[str]:,
build_by_default bool:,
build_rpath str:,
build_subdir str:,
darwin_versions listify[int|str]:,
dependencies listify[dep]:,
export_dynamic bool:,
extra_files listify[both_libs|build_tgt|custom_tgt|file|str]:,
gnu_symbol_visibility str:,
gui_app bool:,
implib bool|str:,
implicit_include_directories bool:,
include_directories listify[inc|str]:,
install bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_rpath str:,
install_tag str:,
install_vala_gir bool|str:,
install_vala_header bool|str:,
install_vala_vapi bool|str:,
link_args listify[str]:,
link_depends listify[build_tgt|custom_tgt|file|str]:,
link_early_args listify[str]:,
link_language str:,
link_whole listify[both_libs|build_tgt|custom_tgt|file]:,
link_with listify[both_libs|build_tgt|custom_tgt|file]:,
name_prefix list|str:,
name_suffix list|str:,
native bool:,
objects listify[file|str]:,
override_options dict[bool|int|list|str]|list[str]|str:,
pic bool:,
pie bool:,
shortname str:,
sources listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
soversion int|str:,
target_type str:,
version str:,
vs_module_defs custom_tgt|file|str:,
win_subsystem str:,

executable(<arguments and keyword arguments>)

build_target(<arguments and keyword arguments>, target_type : 'executable')

The name for this build target, followed by an optional list of sources.

Specifies the intended target of the executable. This can either be executable, if the intended usecase is to run the executable using fork + exec, or application if the executable is supposed to be loaded as shared object by the android runtime.

compiler flags to use for the given language; eg: cpp_args for C++

precompiled header file to use for the given language

Arguments that are only passed to a shared library

Arguments that are only passed to a static library

Causes, when set to true, to have this target be built by default. This means it will be built when meson compile is called without any arguments. The default value is true for all built target types.

A string to add to target's rpath definition in the build dir, but which will be removed on install

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

Defines the compatibility version and current version for the dylib on macOS. If an array is specified, it must be either zero, one, or two elements. If only one element is specified or if it's not an array the specified value will be used for setting both compatibility version and current version. If unspecified, the soversion will be used as per the aforementioned rules.

one or more dependency objects created with [dependency] or [compiler.findlibrary] (for external deps) or [declaredependency] (for deps built by the project)

when set to true causes the target's symbols to be dynamically exported, allowing modules built using the [sharedmodule] function to refer to functions, variables and other symbols defined in the executable itself.

Not used for the build itself but are shown as source files in IDEs that group files by targets (such as Visual Studio).

These may only be static sources.

Specifies how symbols should be exported, see e.g [the GCC Wiki] for more information. This value can either be an empty string or one of default, internal, hidden, protected or inlineshidden, which is the same as hidden but also includes things like C++ implicit constructors as specified in the GCC manual. Ignored on compilers that do not support GNU visibility arguments. See also [snippets.symbol_visibility_header()] method to help with defining public API.

When set to true flags this target as a GUI application on platforms where this makes a difference, deprecated since 0.56.0, use win_subsystem instead.

When set to a string, that will be the name of a generated import library.

Since 1.10.0 passing a boolean value is deprecated.

When set to true, an import library is generated for the executable (the name of the import library is based on exename). Alternatively, when set to a string, that gives the base name for the import library. The import library is used when the returned build target object appears in link_with: elsewhere. Only has any effect on platforms where that is meaningful (e.g. Windows). Implies the export_dynamic argument.

Controls whether Meson adds the current source and build directories to the include path

one or more objects created with the [includedirectories] function, or (since 0.50.0) strings, which will be transparently expanded to include directory objects

When set to true, all outputs of this buildtarget will be installed.

override install directory for outputs of this build target. If the value is a relative path, it will be considered relative the prefix option. For example, if you want to install plugins into a subdir, you'd use something like this: install_dir : get_option('libdir') / 'projectname-1.0'.

This can be set to an array of values to control the the installation path of build targets with multiple outputs. Currently, that means Vala. Setting them to true means "use the default", and false means, don't install. By default the first element is true, and all other elements are false.

Since 1.11.0 Passing an array is deprecated, and installvalaheader, installvalavapi, and installvalagir keyword arguments should be used instead.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string to set the target's rpath to after install (but not before that). On Windows, this argument has no effect.

A string used by the meson install --tags command to install only a subset of the files. By default all build targets have the tag runtime except for static libraries that have the devel tag.

If set to a string value, the vala generated gir library will be installed to that path, if set to true, the default gir path will be used, if false the gir library will not be installed.

It is an error for this to be either true or a string and vala_gir to be unset.

The default value is false.

If set to a string value, the vala generated header will be installed to that path, if set to true, the default include path will be used, if false the header will not be installed.

The default value is false.

If set to a string value, the vala generated vapi library will be installed to that path, if set to true, the default vapi path will be used, if false the vapi library will not be installed.

The default value is false.

Flags to use during linking. You can use UNIX-style flags here for all platforms.

Strings, files, or custom targets the link step depends on such as a symbol visibility map. The purpose is to automatically trigger a re-link (but not a re-compile) of the target when this file changes.

Flags to use during linking. These are just like linkargs, except that they are inserted into the linker command line before any object files or libraries. You can use UNIX-style flags here for all platforms. This is only supported when using the Ninja backend.

Makes the linker for this target be for the specified language. It is generally unnecessary to set this, as Meson will detect the right linker to use in most cases. There are only two cases where this is needed. One, your main function in an executable is not in the language Meson picked, or second you want to force a library to use only one ABI.

(broken until 0.55.0)

Links all contents of the given static libraries whether they are used or not, equivalent to the -Wl,--whole-archive argument flag of GCC, or the '/WHOLEARCHIVE' MSVC linker option. This allows the linked target to re-export symbols from all objects in the static libraries.

(since 0.41.0) If passed an array that array will be flattened.

(since 0.51.0) This argument also accepts outputs produced by custom targets. The user must ensure that the output is a library in the correct format.

One or more shared or static libraries (built by this project) that this target should be linked with. (since 0.41.0) If passed an array that array will be flattened. (since 0.51.0) The arguments can also be custom targets. In this case Meson will assume that merely adding the output file in the linker command line is sufficient to make linking work. If this is not sufficient, then the build system writer must write all other steps manually.

The string that will be used as the prefix for the target output filename by overriding the default (only used for libraries). By default this is lib on all platforms and compilers, except for MSVC shared libraries where it is omitted to follow convention, and Cygwin shared libraries where it is cyg.

Set this to [], or omit the keyword argument for the default behaviour.

The string that will be used as the extension for the target by overriding the default. By default on Windows this is exe for executables and on other platforms it is omitted.

For shared libraries, the default value is dylib on macOS, dll on Windows, and so everywhere else. For static libraries, it is a everywhere. By convention MSVC static libraries use the lib suffix, but we use a to avoid a potential name clash with shared libraries which also generate import libraries with a lib suffix.

Set this to [], or omit the keyword argument for the default behaviour.

Controls whether the target is compiled for the build or host machines.

List of object files that should be linked in this target.

Since 1.1.0 this can include generated files in addition to object files that you don't have source to or that object files produced by other build targets. In earlier release, generated object files had to be placed in sources.

takes an array of strings in the same format as project's default_options overriding the values of these options for this target only. (since 1.2.0): A dictionary may now be passed.

Builds the library as positional independent code (so it can be linked into a shared library). This option has no effect on Windows and OS X since it doesn't make sense on Windows and PIC cannot be disabled on OS X.

Build a position-independent executable.

A string specifying a DLL name fitting to 8.3 limit on OS/2 of this shared library.

Additional source files. Same as the source varargs.

A string or integer specifying the soversion of this shared library, such as 0. On Linux and Windows this is used to set the soversion (or equivalent) in the filename. For example, if soversion is 4, a Windows DLL will be called foo-4.dll and one of the aliases of the Linux shared library would be libfoo.so.4. If this is not specified, the first part of version is used instead (see below). For example, if version is 3.6.0 and soversion is not defined, it is set to 3.

The actual target type to build

A string specifying the version of this shared library, such as 1.1.0. On Linux and OS X, this is used to set the shared library version in the filename, such as libfoo.so.1.1.0 and libfoo.1.1.0.dylib. If this is not specified, soversion is used instead (see above).

Specify a Microsoft module definition file for controlling symbol exports, etc., on platforms where that is possible (e.g. Windows).

This can be used to expose which functions a sharedmodule loaded by an executable will be allowed to use.

Specifies the subsystem type to use on the Windows platform. Typical values include console for text mode programs and windows for gui apps. The value can also contain version specification such as windows,6.0. See [MSDN documentation] for the full list.

dict,

Optional dictionary to specify an initial data set. If provided, each key/value pair is added into the [@cfgdata] object as if the [cfgdata.set] method was called for each of them.

build_subdir str:,
capture bool:,
command list:,
configuration cfg_data|dict:,
copy bool:,
depfile str:,
encoding str:,
format str:,
input listify[both_libs|build_tgt|custom_tgt|file|str]:,
install bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_tag str:,
macro_name str:,
output str:,
output_format str:,

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

When this argument is set to true, Meson captures stdout of the command and writes it to the target file specified as output.

As explained above, if specified, Meson does not create the file itself but rather runs the specified command, which allows you to do fully custom file generation. (since 0.52.0) The command can contain file objects and more than one file can be passed to the input keyword argument, see [customtarget] for details about string substitutions.

As explained above, when passed this will provide the replacement data for the input file (if provided) or key value pairs to be written to the output.

As explained above, if specified Meson only copies the file from input to output.

A dependency file that the command can write listing all the additional files this target depends on. A change in any one of these files triggers a reconfiguration.

Set the file encoding for the input and output file. The supported encodings are those of python3, see [standard-encodings].

The format of defines. It defaults to 'meson', and so substitutes #mesondefine statements and variables surrounded by @ characters, you can also use 'cmake' to replace #cmakedefine statements and variables with the ${variable} syntax. Finally you can use 'cmake@' in which case substitutions will apply on #cmakedefine statements and variables with the @variable@ syntax.

The input file name. If it's not specified in configuration mode, all the variables in the configuration: object (see above) are written to the output: file.

When true, this generated file is installed during the install step, and install_dir must be set and not empty. When false, this generated file is not installed regardless of the value of install_dir. When omitted it defaults to true when install_dir is set and not empty, false otherwise.

The subdirectory to install the generated file to (e.g. share/myproject), if omitted or given the value of empty string, the file is not installed.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string used by the meson install --tags command to install only a subset of the files. By default the file has no install tag which means it is not being installed when --tags argument is specified.

When specified, macro guards will be used instead of '#pragma once'. The macro guard name will be the specified name.

The output file name. (since 0.41.0) may contain @PLAINNAME@ or @BASENAME@ substitutions, as well as (since 1.5.0) their indexed versions, like @PLAINNAME0@ or @BASENAME0@. In configuration mode, the permissions of the input file (if it is specified) are copied to the output file.

The format of the output to generate when no input was specified. It defaults to c, in which case preprocessor directives will be prefixed with #, you can also use nasm, in which case the prefix will be %. (since 1.3.0) json format can also be used.

str,
build_always bool:,
build_always_stale bool:,
build_by_default bool:,
build_subdir str:,
capture bool:,
command listify[exe]:,
console bool:,
depend_files listify[file|str]:,
depends listify[both_libs|build_tgt|custom_tgt|file]:,
depfile str:,
env dict[listify[str]]|env|listify[str]:,
feed bool:,
input listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
install bool:,
install_dir listify[bool|str]:,
install_mode listify[bool|int|str]:,
install_tag str:,
output listify[str]:,

custom_target('foo', output: 'file.txt', ...)

The unique id of the custom target

This posarg is optional since 0.60.0. It defaults to the basename of the first output.

If true this target is always considered out of date and is rebuilt every time. Equivalent to setting both build_always_stale and build_by_default to true.

If true the target is always considered out of date. Useful for things such as build timestamps or revision control tags. The associated command is run even if the outputs are up to date.

Causes, when set to true, to have this target be built by default. This means it will be built when meson compile is called without any arguments. The default value is false.

(since 0.50.0) If build_by_default is explicitly set to false, install will no longer override it. If build_by_default is not set, install will still determine its default.

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

There are some compilers that can't be told to write their output to a file but instead write it to standard output. When this argument is set to true, Meson captures stdout and writes it to the target file. Note that your command argument array may not contain @OUTPUT@ when capture mode is active.

Command to run to create outputs from inputs. The command may be strings or the return value of functions that return file-like objects such as [findprogram], [executable], [configurefile], [files], [customtarget], etc. Meson will automatically insert the appropriate dependencies on targets and files listed in this keyword argument. Note: always specify commands in array form ['commandname', '-arg1', '-arg2'] rather than as a string 'commandname -arg1 -arg2' as the latter will not work.

Note: due to an [issue with path handling] any backslash ( characters are rewritten as slash (/).

Keyword argument conflicts with capture, and is meant for commands that are resource-intensive and take a long time to finish. With the Ninja backend, setting this will add this target to [Ninja's console pool], which has special properties such as not buffering stdout and serializing all targets in this pool.

files ([@str], [@file], or the return value of [configurefile] that this target depends on but are not listed in the command keyword argument. Useful for adding regen dependencies.

Specifies that this target depends on the specified target(s), even though it does not take any of them as a command line argument. This is meant for cases where you have a tool that e.g. does globbing internally. Usually you should just put the generated sources as inputs and Meson will set up all dependencies automatically (customidx was unavailable as a type between 0.60 and 1.4.0).

A dependency file that the command can write listing all the additional files this target depends on, for example a C compiler would list all the header files it included, and a change in any one of these files triggers a recompilation.

(since 0.47.0) the @BASENAME@ and @PLAINNAME@ substitutions are also accepted.

environment variables to set, such as {'NAME1': 'value1', 'NAME2': 'value2'} or ['NAME1=value1', 'NAME2=value2'], or an [@env] object which allows more sophisticated environment juggling.

There are some compilers that can't be told to read their input from a file and instead read it from standard input. When this argument is set to true, Meson feeds the input file to stdin. Note that your argument array may not contain @INPUT@ when feed mode is active.

Array of source files. (since 0.41.0) the array is flattened.

When true, one or more files of this target are installed during the install step (see install_dir for details).

If only one installdir is provided, all outputs are installed there. Since 0.40.0 Allows you to specify the installation directory for each corresponding output. For example: .nf

This would install first.file to somedir and second.file to otherdir.

To only install some outputs, pass false for the outputs that you don't want installed. For example: .nf

This would install second.file to otherdir and not install first.file.

The file mode and optionally the owner/uid and group/gid. See the install_mode kwarg of [installdata] for more information.

An array of strings, one per output, used by the meson install --tags command to install only a subset of the files.

By default all outputs have no install tag which means they are not being installed when --tags argument is specified. If only one tag is specified, it is assumed that all outputs have the same tag. false can be used for outputs that have no tag or are not installed.

Array of output files. These cannot contain path separators.

glob[bool|dict|feature|file|int|list|str],

The message to print

compile_args listify[str]:,
dependencies listify[dep]:,
extra_files listify[both_libs|build_tgt|custom_tgt|file|str]:,
include_directories listify[inc|str]:,
link_args listify[str]:,
link_whole listify[both_libs|build_tgt|custom_tgt|file]:,
link_with listify[both_libs|build_tgt|custom_tgt|file]:,
link_with_raw listify[str]:,
objects listify[file|str]:,
sources listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
variables dict|list|str:,
version str:,

Compile arguments to use.

Other dependencies needed to use this dependency.

extra files to add to targets. mostly used for IDE integration.

the directories to add to header search path, must be [@inc] objects or (since 0.50.0) plain strings.

Link arguments to use.

Libraries to link fully, same as [executable].

Libraries to link against.

an array of object files, to be linked directly into the targets that use the dependency.

sources to add to targets (or generated header files that should be built before sources including them are built)

a dictionary of arbitrary strings, this is meant to be used in subprojects where special variables would be provided via cmake or pkg-config. since 0.56.0 it can also be an array of 'key=value' strings.

the version of this dependency, such as 1.2.3. Defaults to the project version.

glob[str],
allow_fallback bool:,
components listify[str]:,
default_options dict[bool|int|list|str]|list[str]|str:,
disabler bool:,
fallback listify[str]:,
include_type str:,
language str:,
main bool:,
method str:,
modules listify[str]:,
native bool:,
not_found_message str:,
optional_modules listify[str]:,
required bool|feature:,
static bool:,
version listify[str]:,

The names of the dependency to look up. The dependencies are looked up in the order they are provided here. The first found dependency will then be used. The fallback subproject will be used only if none of the names are found on the system. Once one of the name has been found, all other names are added into the cache so subsequent calls for any of those name will return the same value. This is useful in case a dependency could have different names, such as png and libpng.

NOTE: Before 0.60.0 only a single dependency name was allowed.

Specifies whether Meson should automatically pick a fallback subproject in case the dependency is not found in the system. If true and the dependency is not found on the system, Meson will fallback to a subproject that provides this dependency. If false, Meson will not fallback even if a subproject provides this dependency. By default, Meson will do so if required is true or [enabled]; see the [Wrap documentation] for more details.

Ignored

An array of default option values that override those set in the subproject's meson.options (like default_options in [project], they only have effect when Meson is run for the first time, and command line arguments override any default options in build files) (since 1.2.0): A dictionary may now be passed.

Returns a [disabler] object instead of a not-found dependency if this kwarg is set to true and the dependency couldn't be found.

Manually specifies a subproject fallback to use in case the dependency is not found in the system. This is useful if the automatic search is not applicable or if you want to support versions of Meson older than 0.55.0. If the value is an array ['subproj_name', 'subproj_dep'], the first value is the name of the subproject and the second is the variable name in that subproject that contains a dependency object such as the return value of [declaredependency] or [dependency], etc. Note that this means the fallback dependency may be a not-found dependency, in which case the value of the required: kwarg will be obeyed. Since 0.54.0 the value can be a single string, the subproject name; in this case the subproject must use meson.override_dependency('dependency_name', subproj_dep) to specify the dependency object used in the superproject. If the value is an empty array it has the same effect as allow_fallback: false.

An enum flag, marking how the dependency flags should be converted. Supported values are 'preserve', 'system' and 'non-system'. System dependencies may be handled differently on some platforms, for instance, using -isystem instead of -I, where possible. If include_type is set to 'preserve', no additional conversion will be performed.

Ignored

Ignored

Defines the way the dependency is detected, the default is auto but can be overridden to be e.g. qmake for Qt development, and [different dependencies support different values] for this (though auto will work on all of them)

A list of sub-dependencies for this dependency. Only supported by certain dependencies.

If set to true, causes Meson to find the dependency on the build machine system rather than the host system (i.e. where the cross compiled binary will run on), usually only needed if you build a tool to be used during compilation.

An optional string that will be printed as a [message] if the dependency was not found.

Ignored

When set to false, Meson will proceed with the build even if the dependency is not found.

When set to a [feature] option, the feature will control if it is searched and whether to fail if not found.

(since 0.47.0) The value of a feature option can also be passed.

Tells the dependency provider to try to get static libraries instead of dynamic ones (note that this is not supported by all dependency backends)

Leaving this value unset will result in an implementation defined default value. For most dependencies this means the value of the prefer_static option, but some custom dependencies have their own method for determining the most useful default option.

Since 0.60.0 it also sets default_library option accordingly on the fallback subproject if it was not set explicitly in default_options keyword argument.

Since 0.63.0 when the prefer_static option is used to calculate the default value.

Specifies the required version, a string containing a comparison operator followed by the version string, examples include >1.0.0, <=2.3.5 or 3.1.4 for exact matching. You can also specify multiple restrictions by passing an array to this keyword argument, such as: ['>=3.14.0', '<=4.1.0']. These requirements are never met if the version is unknown.

dict[listify[str]]|listify[str],
method str[append|prepend|set]:,
separator str:,

If provided, each key/value pair is added into the [@env] object as if [env.set] method was called for each of them. Since 0.62.0 arrays of strings are allowed in dictionary values. In that case values are joined using the separator.

Must be one of 'set', 'prepend', or 'append' (defaults to 'set'). Controls if initial values defined in the first positional argument are prepended, appended or replace the current value of the environment variable.

The separator to use for the initial values defined in the first positional argument. If not explicitly specified, the default path separator for the host operating system will be used, i.e. ';' for Windows and ':' for UNIX/POSIX systems.

glob[bool|dict|feature|file|int|list|str],

The message to print

glob[both_libs|build_tgt|custom_tgt|file|generated_list|str],
android_exe_type str:,
<lang>_args listify[str]:,
<lang>_pch build_tgt|file|list|str:,
<lang>_shared_args listify[str]:,
<lang>_static_args listify[str]:,
build_by_default bool:,
build_rpath str:,
build_subdir str:,
darwin_versions listify[int|str]:,
dependencies listify[dep]:,
export_dynamic bool:,
extra_files listify[both_libs|build_tgt|custom_tgt|file|str]:,
gnu_symbol_visibility str:,
gui_app bool:,
implib bool|str:,
implicit_include_directories bool:,
include_directories listify[inc|str]:,
install bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_rpath str:,
install_tag str:,
install_vala_gir bool|str:,
install_vala_header bool|str:,
install_vala_vapi bool|str:,
link_args listify[str]:,
link_depends listify[build_tgt|custom_tgt|file|str]:,
link_early_args listify[str]:,
link_language str:,
link_whole listify[both_libs|build_tgt|custom_tgt|file]:,
link_with listify[both_libs|build_tgt|custom_tgt|file]:,
name_prefix list|str:,
name_suffix list|str:,
native bool:,
objects listify[file|str]:,
override_options dict[bool|int|list|str]|list[str]|str:,
pic bool:,
pie bool:,
shortname str:,
sources listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
soversion int|str:,
target_type str:,
version str:,
vs_module_defs custom_tgt|file|str:,
win_subsystem str:,

The name for this build target, followed by an optional list of sources.

Specifies the intended target of the executable. This can either be executable, if the intended usecase is to run the executable using fork + exec, or application if the executable is supposed to be loaded as shared object by the android runtime.

compiler flags to use for the given language; eg: cpp_args for C++

precompiled header file to use for the given language

Arguments that are only passed to a shared library

Arguments that are only passed to a static library

Causes, when set to true, to have this target be built by default. This means it will be built when meson compile is called without any arguments. The default value is true for all built target types.

A string to add to target's rpath definition in the build dir, but which will be removed on install

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

Defines the compatibility version and current version for the dylib on macOS. If an array is specified, it must be either zero, one, or two elements. If only one element is specified or if it's not an array the specified value will be used for setting both compatibility version and current version. If unspecified, the soversion will be used as per the aforementioned rules.

one or more dependency objects created with [dependency] or [compiler.findlibrary] (for external deps) or [declaredependency] (for deps built by the project)

when set to true causes the target's symbols to be dynamically exported, allowing modules built using the [sharedmodule] function to refer to functions, variables and other symbols defined in the executable itself.

Not used for the build itself but are shown as source files in IDEs that group files by targets (such as Visual Studio).

These may only be static sources.

Specifies how symbols should be exported, see e.g [the GCC Wiki] for more information. This value can either be an empty string or one of default, internal, hidden, protected or inlineshidden, which is the same as hidden but also includes things like C++ implicit constructors as specified in the GCC manual. Ignored on compilers that do not support GNU visibility arguments. See also [snippets.symbol_visibility_header()] method to help with defining public API.

When set to true flags this target as a GUI application on platforms where this makes a difference, deprecated since 0.56.0, use win_subsystem instead.

When set to a string, that will be the name of a generated import library.

Since 1.10.0 passing a boolean value is deprecated.

When set to true, an import library is generated for the executable (the name of the import library is based on exename). Alternatively, when set to a string, that gives the base name for the import library. The import library is used when the returned build target object appears in link_with: elsewhere. Only has any effect on platforms where that is meaningful (e.g. Windows). Implies the export_dynamic argument.

Controls whether Meson adds the current source and build directories to the include path

one or more objects created with the [includedirectories] function, or (since 0.50.0) strings, which will be transparently expanded to include directory objects

When set to true, all outputs of this buildtarget will be installed.

override install directory for outputs of this build target. If the value is a relative path, it will be considered relative the prefix option. For example, if you want to install plugins into a subdir, you'd use something like this: install_dir : get_option('libdir') / 'projectname-1.0'.

This can be set to an array of values to control the the installation path of build targets with multiple outputs. Currently, that means Vala. Setting them to true means "use the default", and false means, don't install. By default the first element is true, and all other elements are false.

Since 1.11.0 Passing an array is deprecated, and installvalaheader, installvalavapi, and installvalagir keyword arguments should be used instead.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string to set the target's rpath to after install (but not before that). On Windows, this argument has no effect.

A string used by the meson install --tags command to install only a subset of the files. By default all build targets have the tag runtime except for static libraries that have the devel tag.

If set to a string value, the vala generated gir library will be installed to that path, if set to true, the default gir path will be used, if false the gir library will not be installed.

It is an error for this to be either true or a string and vala_gir to be unset.

The default value is false.

If set to a string value, the vala generated header will be installed to that path, if set to true, the default include path will be used, if false the header will not be installed.

The default value is false.

If set to a string value, the vala generated vapi library will be installed to that path, if set to true, the default vapi path will be used, if false the vapi library will not be installed.

The default value is false.

Flags to use during linking. You can use UNIX-style flags here for all platforms.

Strings, files, or custom targets the link step depends on such as a symbol visibility map. The purpose is to automatically trigger a re-link (but not a re-compile) of the target when this file changes.

Flags to use during linking. These are just like linkargs, except that they are inserted into the linker command line before any object files or libraries. You can use UNIX-style flags here for all platforms. This is only supported when using the Ninja backend.

Makes the linker for this target be for the specified language. It is generally unnecessary to set this, as Meson will detect the right linker to use in most cases. There are only two cases where this is needed. One, your main function in an executable is not in the language Meson picked, or second you want to force a library to use only one ABI.

(broken until 0.55.0)

Links all contents of the given static libraries whether they are used or not, equivalent to the -Wl,--whole-archive argument flag of GCC, or the '/WHOLEARCHIVE' MSVC linker option. This allows the linked target to re-export symbols from all objects in the static libraries.

(since 0.41.0) If passed an array that array will be flattened.

(since 0.51.0) This argument also accepts outputs produced by custom targets. The user must ensure that the output is a library in the correct format.

One or more shared or static libraries (built by this project) that this target should be linked with. (since 0.41.0) If passed an array that array will be flattened. (since 0.51.0) The arguments can also be custom targets. In this case Meson will assume that merely adding the output file in the linker command line is sufficient to make linking work. If this is not sufficient, then the build system writer must write all other steps manually.

The string that will be used as the prefix for the target output filename by overriding the default (only used for libraries). By default this is lib on all platforms and compilers, except for MSVC shared libraries where it is omitted to follow convention, and Cygwin shared libraries where it is cyg.

Set this to [], or omit the keyword argument for the default behaviour.

The string that will be used as the extension for the target by overriding the default. By default on Windows this is exe for executables and on other platforms it is omitted.

For shared libraries, the default value is dylib on macOS, dll on Windows, and so everywhere else. For static libraries, it is a everywhere. By convention MSVC static libraries use the lib suffix, but we use a to avoid a potential name clash with shared libraries which also generate import libraries with a lib suffix.

Set this to [], or omit the keyword argument for the default behaviour.

Controls whether the target is compiled for the build or host machines.

List of object files that should be linked in this target.

Since 1.1.0 this can include generated files in addition to object files that you don't have source to or that object files produced by other build targets. In earlier release, generated object files had to be placed in sources.

takes an array of strings in the same format as project's default_options overriding the values of these options for this target only. (since 1.2.0): A dictionary may now be passed.

Builds the library as positional independent code (so it can be linked into a shared library). This option has no effect on Windows and OS X since it doesn't make sense on Windows and PIC cannot be disabled on OS X.

Build a position-independent executable.

A string specifying a DLL name fitting to 8.3 limit on OS/2 of this shared library.

Additional source files. Same as the source varargs.

A string or integer specifying the soversion of this shared library, such as 0. On Linux and Windows this is used to set the soversion (or equivalent) in the filename. For example, if soversion is 4, a Windows DLL will be called foo-4.dll and one of the aliases of the Linux shared library would be libfoo.so.4. If this is not specified, the first part of version is used instead (see below). For example, if version is 3.6.0 and soversion is not defined, it is set to 3.

The actual target type to build

A string specifying the version of this shared library, such as 1.1.0. On Linux and OS X, this is used to set the shared library version in the filename, such as libfoo.so.1.1.0 and libfoo.1.1.0.dylib. If this is not specified, soversion is used instead (see above).

Specify a Microsoft module definition file for controlling symbol exports, etc., on platforms where that is possible (e.g. Windows).

This can be used to expose which functions a sharedmodule loaded by an executable will be allowed to use.

Specifies the subsystem type to use on the Windows platform. Typical values include console for text mode programs and windows for gui apps. The value can also contain version specification such as windows,6.0. See [MSDN documentation] for the full list.

glob[str],

Path to the file.

glob[file|str],
default_options dict[bool|int|list|str]|list[str]|str:,
dirs listify[str]:,
disabler bool:,
native bool:,
required bool|feature:,
version listify[str]:,
version_argument str:,

setcap = find_program('setcap', '/usr/sbin/setcap', '/sbin/setcap', required : false)

setcap = find_program(['setcap', '/usr/sbin/setcap', '/sbin/setcap'], required : false)

The name of the program to search, or a [@file] object to be used without searching.

An array of default option values that override those set in the subproject's meson.options (like default_options in [project], they only have effect when Meson is run for the first time, and command line arguments override any default options in build files)

extra array of absolute paths where to look for program names.

If true and the program couldn't be found, return a [@disabler] object instead of a not-found object.

Defines how this executable should be searched. By default it is set to false, which causes Meson to first look for the executable in the cross file (when cross building) and if it is not defined there, then from the system. If set to true, the cross file is ignored and the program is only searched from the system.

When true, Meson will abort if no program can be found. If required is set to false, Meson continue even if none of the programs can be found. You can then use the .found() method on the returned [@program] to check whether it was found or not. (since 0.47.0) The value of a [feature] option can also be passed to the required keyword argument.

Specifies the required version, see [dependency] for argument format. By default, the version of the program is determined by running program_name --version command. If stdout is empty it fallbacks to stderr. If the output contains more text than simply a version number, only the first occurrence of numbers separated by dots is kept. If the output is more complicated than that, the version checking will have to be done manually using [runcommand].

Specifies the argument to pass when trying to find the version of the program. If this is unspecified, program_name --version will be used.

exe,
arguments list:,
capture bool:,
depends listify[both_libs|build_tgt|custom_tgt|file]:,
depfile str:,
output listify[str]:,

Executable for the command to run

An array of template strings that will be the command line arguments passed to the executable.

When this argument is set to true, Meson captures stdout of the executable and writes it to the target file specified as output.

An array of build targets that must be built before this generator can be run. This is used if you have a generator that calls a second executable that is built in this project (customidx was not available between 0.60 and 1.4.0).

A template string pointing to a dependency file that a generator can write listing all the additional files this target depends on, for example a C compiler would list all the header files it included, and a change in any one of these files triggers a recompilation,

Template string (or array of template strings) defining how an output file name is (or multiple output names are) generated from a single source file name.

str,

Name of the option to query

any,
any,

Name of the variable to get

Fallback value to return when the variable does not exist

str,
disabler bool:,
required bool|feature:,

Name of the module to import.

Returns a [@disabler] object when not found.

When set to false, Meson will proceed with the build even if the module is not found. When set to a [feature] option, the feature will control if it is searched and whether to fail if not found.

glob[inc|str],
is_system bool:,

Include paths to add.

If set to true, flags the specified directories as system directories. This means that they will be used with the -isystem compiler argument rather than -I on compilers that support this flag (in practice everything except Visual Studio).

glob[file|str],
follow_symlinks bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_tag str:,
preserve_path bool:,
rename listify[str]:,
sources listify[file|str]:,

Files to install.

If true, dereferences links and copies their target instead. The default value will become false in the future.

The absolute or relative path to the installation directory. If this is a relative path, it is assumed to be relative to the prefix.

If omitted, the directory defaults to {datadir}/{projectname} (since 0.45.0).

specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files. For example:

install_mode: 'rw-r--r--' for just the file mode

install_mode: ['rw-r--r--', 'nobody', 'nogroup'] for the file mode and the user/group

install_mode: ['rw-r-----', 0, 0] for the file mode and uid/gid

To leave any of these three as the default, specify false.

A string used by the meson install --tags command to install only a subset of the files. By default these files have no install tag which means they are not being installed when --tags argument is specified.

Disable stripping child-directories from data files when installing.

This is equivalent to GNU Automake's nobase option.

If specified renames each source file into corresponding file from rename array. Nested paths are allowed and they are joined with install_dir. Length of rename array must be equal to the number of sources.

Additional files to install.

glob[str],
install_mode listify[bool|int|str]:,
install_tag str:,

Directory to create during installation.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the created directory.

See the install_mode kwarg of [installdata] for more information.

A string used by the meson install --tags command to install only a subset of the files. By default this directory has no install tag which means it is not installed when the --tags argument is specified.

glob[file|str],
follow_symlinks bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_tag str:,
preserve_path bool:,
subdir str:,

Header files to install.

If true, dereferences links and copies their target instead. The default value will become false in the future.

Where to install to.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string used by the meson install --tags command to install only a subset of the files. By default these files have the devel install tag which means they are installed explicitly or when no tags given at all.

Disable stripping child-directories from header files when installing.

This is equivalent to GNU Automake's nobase option.

Install to the subdir subdirectory of the default includedir.

Incompatible with the install_dir kwarg.

glob[both_libs|build_tgt|custom_tgt|file|str],
install_dir str:,
install_mode listify[bool|int|str]:,
install_tag str:,
locale str:,

Man pages to install.

Where to install to.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string used by the meson install --tags command to install only a subset of the files. By default these files have man install tag which means they are installed explicitly or when no tags given at all

Can be used to specify the locale into which the man page will be installed within the manual page directory tree. An example manual might be foo.fr.1 with a locale of fr, such that {mandir}/{locale}/man{num}/foo.1 becomes the installed file.

str,
exclude_directories listify[str]:,
exclude_files listify[str]:,
follow_symlinks bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_tag str:,
strip_directory bool:,

The sub-directory to install

An array of directory names that should not be installed. Names are interpreted as paths relative to the subdir_name location.

An array of file names that should not be installed. Names are interpreted as paths relative to the subdir_name location.

If true, dereferences links and copies their target instead. The default value will become false in the future.

Where to install to.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string used by the meson install --tags command to install only a subset of the files. By default these files have no install tag which means they are not being installed when --tags argument is specified.

Install directory contents. If strip_directory=true only the last component of the source path is used.

str,
install_dir str:,
install_tag str:,
pointing_to str:,

Name of the created link under install_dir. It cannot contain path separators. Those should go in install_dir.

The absolute or relative path to the installation directory for the links. If this is a relative path, it is assumed to be relative to the prefix.

A string used by the meson install --tags command to install only a subset of the files. By default these files have no install tag which means they are not being installed when --tags argument is specified.

Target to point the link to. Can be absolute or relative and that will be respected when creating the link.

any,

The variable to test

any|null,

str,

The variable to test

glob[str],

# res1 and res2 will have identical values
res1 = join_paths(foo, bar)
res2 = foo / bar

The path parts to join.

glob[both_libs|build_tgt|custom_tgt|file|generated_list|str],
android_exe_type str:,
<lang>_args listify[str]:,
<lang>_pch build_tgt|file|list|str:,
<lang>_shared_args listify[str]:,
<lang>_static_args listify[str]:,
build_by_default bool:,
build_rpath str:,
build_subdir str:,
darwin_versions listify[int|str]:,
dependencies listify[dep]:,
export_dynamic bool:,
extra_files listify[both_libs|build_tgt|custom_tgt|file|str]:,
gnu_symbol_visibility str:,
gui_app bool:,
implib bool|str:,
implicit_include_directories bool:,
include_directories listify[inc|str]:,
install bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_rpath str:,
install_tag str:,
install_vala_gir bool|str:,
install_vala_header bool|str:,
install_vala_vapi bool|str:,
link_args listify[str]:,
link_depends listify[build_tgt|custom_tgt|file|str]:,
link_early_args listify[str]:,
link_language str:,
link_whole listify[both_libs|build_tgt|custom_tgt|file]:,
link_with listify[both_libs|build_tgt|custom_tgt|file]:,
name_prefix list|str:,
name_suffix list|str:,
native bool:,
objects listify[file|str]:,
override_options dict[bool|int|list|str]|list[str]|str:,
pic bool:,
pie bool:,
shortname str:,
sources listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
soversion int|str:,
target_type str:,
version str:,
vs_module_defs custom_tgt|file|str:,
win_subsystem str:,

The name for this build target, followed by an optional list of sources.

Specifies the intended target of the executable. This can either be executable, if the intended usecase is to run the executable using fork + exec, or application if the executable is supposed to be loaded as shared object by the android runtime.

compiler flags to use for the given language; eg: cpp_args for C++

precompiled header file to use for the given language

Arguments that are only passed to a shared library

Arguments that are only passed to a static library

Causes, when set to true, to have this target be built by default. This means it will be built when meson compile is called without any arguments. The default value is true for all built target types.

A string to add to target's rpath definition in the build dir, but which will be removed on install

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

Defines the compatibility version and current version for the dylib on macOS. If an array is specified, it must be either zero, one, or two elements. If only one element is specified or if it's not an array the specified value will be used for setting both compatibility version and current version. If unspecified, the soversion will be used as per the aforementioned rules.

one or more dependency objects created with [dependency] or [compiler.findlibrary] (for external deps) or [declaredependency] (for deps built by the project)

when set to true causes the target's symbols to be dynamically exported, allowing modules built using the [sharedmodule] function to refer to functions, variables and other symbols defined in the executable itself.

Not used for the build itself but are shown as source files in IDEs that group files by targets (such as Visual Studio).

These may only be static sources.

Specifies how symbols should be exported, see e.g [the GCC Wiki] for more information. This value can either be an empty string or one of default, internal, hidden, protected or inlineshidden, which is the same as hidden but also includes things like C++ implicit constructors as specified in the GCC manual. Ignored on compilers that do not support GNU visibility arguments. See also [snippets.symbol_visibility_header()] method to help with defining public API.

When set to true flags this target as a GUI application on platforms where this makes a difference, deprecated since 0.56.0, use win_subsystem instead.

When set to a string, that will be the name of a generated import library.

Since 1.10.0 passing a boolean value is deprecated.

When set to true, an import library is generated for the executable (the name of the import library is based on exename). Alternatively, when set to a string, that gives the base name for the import library. The import library is used when the returned build target object appears in link_with: elsewhere. Only has any effect on platforms where that is meaningful (e.g. Windows). Implies the export_dynamic argument.

Controls whether Meson adds the current source and build directories to the include path

one or more objects created with the [includedirectories] function, or (since 0.50.0) strings, which will be transparently expanded to include directory objects

When set to true, all outputs of this buildtarget will be installed.

override install directory for outputs of this build target. If the value is a relative path, it will be considered relative the prefix option. For example, if you want to install plugins into a subdir, you'd use something like this: install_dir : get_option('libdir') / 'projectname-1.0'.

This can be set to an array of values to control the the installation path of build targets with multiple outputs. Currently, that means Vala. Setting them to true means "use the default", and false means, don't install. By default the first element is true, and all other elements are false.

Since 1.11.0 Passing an array is deprecated, and installvalaheader, installvalavapi, and installvalagir keyword arguments should be used instead.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string to set the target's rpath to after install (but not before that). On Windows, this argument has no effect.

A string used by the meson install --tags command to install only a subset of the files. By default all build targets have the tag runtime except for static libraries that have the devel tag.

If set to a string value, the vala generated gir library will be installed to that path, if set to true, the default gir path will be used, if false the gir library will not be installed.

It is an error for this to be either true or a string and vala_gir to be unset.

The default value is false.

If set to a string value, the vala generated header will be installed to that path, if set to true, the default include path will be used, if false the header will not be installed.

The default value is false.

If set to a string value, the vala generated vapi library will be installed to that path, if set to true, the default vapi path will be used, if false the vapi library will not be installed.

The default value is false.

Flags to use during linking. You can use UNIX-style flags here for all platforms.

Strings, files, or custom targets the link step depends on such as a symbol visibility map. The purpose is to automatically trigger a re-link (but not a re-compile) of the target when this file changes.

Flags to use during linking. These are just like linkargs, except that they are inserted into the linker command line before any object files or libraries. You can use UNIX-style flags here for all platforms. This is only supported when using the Ninja backend.

Makes the linker for this target be for the specified language. It is generally unnecessary to set this, as Meson will detect the right linker to use in most cases. There are only two cases where this is needed. One, your main function in an executable is not in the language Meson picked, or second you want to force a library to use only one ABI.

(broken until 0.55.0)

Links all contents of the given static libraries whether they are used or not, equivalent to the -Wl,--whole-archive argument flag of GCC, or the '/WHOLEARCHIVE' MSVC linker option. This allows the linked target to re-export symbols from all objects in the static libraries.

(since 0.41.0) If passed an array that array will be flattened.

(since 0.51.0) This argument also accepts outputs produced by custom targets. The user must ensure that the output is a library in the correct format.

One or more shared or static libraries (built by this project) that this target should be linked with. (since 0.41.0) If passed an array that array will be flattened. (since 0.51.0) The arguments can also be custom targets. In this case Meson will assume that merely adding the output file in the linker command line is sufficient to make linking work. If this is not sufficient, then the build system writer must write all other steps manually.

The string that will be used as the prefix for the target output filename by overriding the default (only used for libraries). By default this is lib on all platforms and compilers, except for MSVC shared libraries where it is omitted to follow convention, and Cygwin shared libraries where it is cyg.

Set this to [], or omit the keyword argument for the default behaviour.

The string that will be used as the extension for the target by overriding the default. By default on Windows this is exe for executables and on other platforms it is omitted.

For shared libraries, the default value is dylib on macOS, dll on Windows, and so everywhere else. For static libraries, it is a everywhere. By convention MSVC static libraries use the lib suffix, but we use a to avoid a potential name clash with shared libraries which also generate import libraries with a lib suffix.

Set this to [], or omit the keyword argument for the default behaviour.

Controls whether the target is compiled for the build or host machines.

List of object files that should be linked in this target.

Since 1.1.0 this can include generated files in addition to object files that you don't have source to or that object files produced by other build targets. In earlier release, generated object files had to be placed in sources.

takes an array of strings in the same format as project's default_options overriding the values of these options for this target only. (since 1.2.0): A dictionary may now be passed.

Builds the library as positional independent code (so it can be linked into a shared library). This option has no effect on Windows and OS X since it doesn't make sense on Windows and PIC cannot be disabled on OS X.

Build a position-independent executable.

A string specifying a DLL name fitting to 8.3 limit on OS/2 of this shared library.

Additional source files. Same as the source varargs.

A string or integer specifying the soversion of this shared library, such as 0. On Linux and Windows this is used to set the soversion (or equivalent) in the filename. For example, if soversion is 4, a Windows DLL will be called foo-4.dll and one of the aliases of the Linux shared library would be libfoo.so.4. If this is not specified, the first part of version is used instead (see below). For example, if version is 3.6.0 and soversion is not defined, it is set to 3.

The actual target type to build

A string specifying the version of this shared library, such as 1.1.0. On Linux and OS X, this is used to set the shared library version in the filename, such as libfoo.so.1.1.0 and libfoo.1.1.0.dylib. If this is not specified, soversion is used instead (see above).

Specify a Microsoft module definition file for controlling symbol exports, etc., on platforms where that is possible (e.g. Windows).

(Since 1.3.0) [@customidx] are supported

Specifies the subsystem type to use on the Windows platform. Typical values include console for text mode programs and windows for gui apps. The value can also contain version specification such as windows,6.0. See [MSDN documentation] for the full list.

glob[bool|dict|feature|file|int|list|str],

The message to print.

str,
choices list:,
deprecated bool|str|dict[str]|list[str]:,
description str:,
max int:,
min int:,
type str:,
value any:,
yield bool:,

any|null,
inspect bool:,
pretty bool:,

str,

str,
glob[str],
default_options dict[bool|int|list|str]|list[str]|str:,
license listify[str]:,
license_files listify[str]:,
meson_version str:,
module_dir str:,
subproject_dir str:,
version file|str:,

The name of the project.

The languages that Meson should initialize.

Accepts strings in the form key=value which have the same format as options to meson configure. For example to set the default project type you would set this: default_options : ['buildtype=debugoptimized']. Note that these settings are only used when running Meson for the first time.

Note that some options can override the default behavior; for example, using c_args here means that the CFLAGS environment variable is not used. Consider using [addprojectarguments()] instead.

Also note that not all options are taken into account when building as a subproject, and the exact set of options that are per-subproject has increased over time; for more information, see [core options] and [compiler options].

(since 1.2.0): A dictionary may now be passed.

Takes a string or array of strings describing the license(s) the code is under.

This should be an [SPDX license expression], using the standardized license identifier from the [SPDX license list]. Usually this would be something like license : 'GPL-2.0-or-later'. If there are multiple licenses you can use the AND and OR operators to join them: license : 'Apache-2.0 OR GPL-2.0'.

For backwards compatibility reasons you can also pass an array of licenses here. This is not recommended, as it is ambiguous: license : ['Apache-2.0', 'GPL-2.0-only'] instead use an SPDX expression: license : 'Apache-2.0 OR GPL-2.0-only', which makes it clear that the license mean OR, not AND.

Note that the text is informal and is only written to the dependency manifest. Meson does not do any license validation, you are responsible for verifying that you abide by all licensing terms. You can access the value in your Meson build files with meson.project_license().

Takes a string or array of strings with the paths to the license file(s) the code is under.

This enhances the value of the license kwarg by allowing to specify both the short license name and the full license text. Usually this would be something like license_files: ['COPYING'].

Note that the files are informal and are only installed with the dependency manifest. Meson does not do any license validation, you are responsible for verifying that you abide by all licensing terms. You can access the value in your Meson build files with [meson.projectlicensefiles].

Takes a string describing which Meson version the project requires. Usually something like >=0.28.0.

Specify a directory to search for .meson files in when import()-ing modules

Specifies the top level directory name that holds Meson subprojects. This is only meant as a compatibility option for existing code bases that house their embedded source code in a custom directory. All new projects should not set this but instead use the default value. It should be noted that this keyword argument is ignored inside subprojects. There can be only one subproject dir and it is set in the top level Meson file.

A free form string describing the version of this project. You can access the value in your Meson build files with [meson.projectversion]. (Since 0.57.0) this can also be a [@file] object pointing to a file that contains exactly one line of text.

int,
int,
int,

The start of the range

The end of the range

The loop increment

glob[compiler|external_program|file|python_installation|str],
capture bool:,
check bool:,
console bool:,
env dict[listify[str]]|env|listify[str]:,
feed both_libs|build_tgt|custom_tgt|file|str:,

The command to execute during the setup process.

If true, any output generated on stdout will be captured and returned by the .stdout() method. If it is false, then .stdout() will return an empty string.

If true, the exit status code of the command will be checked, and the configuration will fail if it is non-zero. Note that the default value will be true in future releases.

stdout and stderr are written to console as it is generated by the command. Meant for commands that are resource-intensive and take a long time to finish.

environment variables to set, such as ['NAME1=value1', 'NAME2=value2'], or an [@env] object which allows more sophisticated environment juggling. (Since 0.52.0) A dictionary is also accepted.

Specify a file to be used for stdin

str,
command listify[exe]:,
depends listify[both_libs|build_tgt|custom_tgt|file]:,
env dict[listify[str]]|env|listify[str]:,

The name of the run target

An array containing the command to run and the arguments to pass to it. Each array element may be a string or a target. For instance, passing the return value of [executable] as the first item will run that executable, or passing a string as the first item will find that command in PATH and run it.

An array of targets that this target depends on but which are not listed in the command array (because, for example, the script does file globbing internally, customidx was not possible as a type between 0.60 and 1.4.0).

environment variables to set, such as {'NAME1': 'value1', 'NAME2': 'value2'} or ['NAME1=value1', 'NAME2=value2'], or an [@env] object which allows more sophisticated environment juggling.

str,
any,

The name of the variable to set

The value to set the variable to

glob[both_libs|build_tgt|custom_tgt|file|generated_list|str],
android_exe_type str:,
<lang>_args listify[str]:,
<lang>_pch build_tgt|file|list|str:,
<lang>_shared_args listify[str]:,
<lang>_static_args listify[str]:,
build_by_default bool:,
build_rpath str:,
build_subdir str:,
darwin_versions listify[int|str]:,
dependencies listify[dep]:,
export_dynamic bool:,
extra_files listify[both_libs|build_tgt|custom_tgt|file|str]:,
gnu_symbol_visibility str:,
gui_app bool:,
implib bool|str:,
implicit_include_directories bool:,
include_directories listify[inc|str]:,
install bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_rpath str:,
install_tag str:,
install_vala_gir bool|str:,
install_vala_header bool|str:,
install_vala_vapi bool|str:,
link_args listify[str]:,
link_depends listify[build_tgt|custom_tgt|file|str]:,
link_early_args listify[str]:,
link_language str:,
link_whole listify[both_libs|build_tgt|custom_tgt|file]:,
link_with listify[both_libs|build_tgt|custom_tgt|file]:,
name_prefix list|str:,
name_suffix list|str:,
native bool:,
objects listify[file|str]:,
override_options dict[bool|int|list|str]|list[str]|str:,
pic bool:,
pie bool:,
shortname str:,
sources listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
soversion int|str:,
target_type str:,
version str:,
vs_module_defs custom_tgt|file|str:,
win_subsystem str:,

The name for this build target, followed by an optional list of sources.

Specifies the intended target of the executable. This can either be executable, if the intended usecase is to run the executable using fork + exec, or application if the executable is supposed to be loaded as shared object by the android runtime.

compiler flags to use for the given language; eg: cpp_args for C++

precompiled header file to use for the given language

Arguments that are only passed to a shared library

Arguments that are only passed to a static library

Causes, when set to true, to have this target be built by default. This means it will be built when meson compile is called without any arguments. The default value is true for all built target types.

A string to add to target's rpath definition in the build dir, but which will be removed on install

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

Defines the compatibility version and current version for the dylib on macOS. If an array is specified, it must be either zero, one, or two elements. If only one element is specified or if it's not an array the specified value will be used for setting both compatibility version and current version. If unspecified, the soversion will be used as per the aforementioned rules.

one or more dependency objects created with [dependency] or [compiler.findlibrary] (for external deps) or [declaredependency] (for deps built by the project)

when set to true causes the target's symbols to be dynamically exported, allowing modules built using the [sharedmodule] function to refer to functions, variables and other symbols defined in the executable itself.

Not used for the build itself but are shown as source files in IDEs that group files by targets (such as Visual Studio).

These may only be static sources.

Specifies how symbols should be exported, see e.g [the GCC Wiki] for more information. This value can either be an empty string or one of default, internal, hidden, protected or inlineshidden, which is the same as hidden but also includes things like C++ implicit constructors as specified in the GCC manual. Ignored on compilers that do not support GNU visibility arguments. See also [snippets.symbol_visibility_header()] method to help with defining public API.

When set to true flags this target as a GUI application on platforms where this makes a difference, deprecated since 0.56.0, use win_subsystem instead.

When set to a string, that will be the name of a generated import library.

Since 1.10.0 passing a boolean value is deprecated.

When set to true, an import library is generated for the executable (the name of the import library is based on exename). Alternatively, when set to a string, that gives the base name for the import library. The import library is used when the returned build target object appears in link_with: elsewhere. Only has any effect on platforms where that is meaningful (e.g. Windows). Implies the export_dynamic argument.

Controls whether Meson adds the current source and build directories to the include path

one or more objects created with the [includedirectories] function, or (since 0.50.0) strings, which will be transparently expanded to include directory objects

When set to true, all outputs of this buildtarget will be installed.

override install directory for outputs of this build target. If the value is a relative path, it will be considered relative the prefix option. For example, if you want to install plugins into a subdir, you'd use something like this: install_dir : get_option('libdir') / 'projectname-1.0'.

This can be set to an array of values to control the the installation path of build targets with multiple outputs. Currently, that means Vala. Setting them to true means "use the default", and false means, don't install. By default the first element is true, and all other elements are false.

Since 1.11.0 Passing an array is deprecated, and installvalaheader, installvalavapi, and installvalagir keyword arguments should be used instead.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string to set the target's rpath to after install (but not before that). On Windows, this argument has no effect.

A string used by the meson install --tags command to install only a subset of the files. By default all build targets have the tag runtime except for static libraries that have the devel tag.

If set to a string value, the vala generated gir library will be installed to that path, if set to true, the default gir path will be used, if false the gir library will not be installed.

It is an error for this to be either true or a string and vala_gir to be unset.

The default value is false.

If set to a string value, the vala generated header will be installed to that path, if set to true, the default include path will be used, if false the header will not be installed.

The default value is false.

If set to a string value, the vala generated vapi library will be installed to that path, if set to true, the default vapi path will be used, if false the vapi library will not be installed.

The default value is false.

Flags to use during linking. You can use UNIX-style flags here for all platforms.

Strings, files, or custom targets the link step depends on such as a symbol visibility map. The purpose is to automatically trigger a re-link (but not a re-compile) of the target when this file changes.

Flags to use during linking. These are just like linkargs, except that they are inserted into the linker command line before any object files or libraries. You can use UNIX-style flags here for all platforms. This is only supported when using the Ninja backend.

Makes the linker for this target be for the specified language. It is generally unnecessary to set this, as Meson will detect the right linker to use in most cases. There are only two cases where this is needed. One, your main function in an executable is not in the language Meson picked, or second you want to force a library to use only one ABI.

(broken until 0.55.0)

Links all contents of the given static libraries whether they are used or not, equivalent to the -Wl,--whole-archive argument flag of GCC, or the '/WHOLEARCHIVE' MSVC linker option. This allows the linked target to re-export symbols from all objects in the static libraries.

(since 0.41.0) If passed an array that array will be flattened.

(since 0.51.0) This argument also accepts outputs produced by custom targets. The user must ensure that the output is a library in the correct format.

One or more shared or static libraries (built by this project) that this target should be linked with. (since 0.41.0) If passed an array that array will be flattened. (since 0.51.0) The arguments can also be custom targets. In this case Meson will assume that merely adding the output file in the linker command line is sufficient to make linking work. If this is not sufficient, then the build system writer must write all other steps manually.

The string that will be used as the prefix for the target output filename by overriding the default (only used for libraries). By default this is lib on all platforms and compilers, except for MSVC shared libraries where it is omitted to follow convention, and Cygwin shared libraries where it is cyg.

Set this to [], or omit the keyword argument for the default behaviour.

The string that will be used as the extension for the target by overriding the default. By default on Windows this is exe for executables and on other platforms it is omitted.

For shared libraries, the default value is dylib on macOS, dll on Windows, and so everywhere else. For static libraries, it is a everywhere. By convention MSVC static libraries use the lib suffix, but we use a to avoid a potential name clash with shared libraries which also generate import libraries with a lib suffix.

Set this to [], or omit the keyword argument for the default behaviour.

Controls whether the target is compiled for the build or host machines.

List of object files that should be linked in this target.

Since 1.1.0 this can include generated files in addition to object files that you don't have source to or that object files produced by other build targets. In earlier release, generated object files had to be placed in sources.

takes an array of strings in the same format as project's default_options overriding the values of these options for this target only. (since 1.2.0): A dictionary may now be passed.

Builds the library as positional independent code (so it can be linked into a shared library). This option has no effect on Windows and OS X since it doesn't make sense on Windows and PIC cannot be disabled on OS X.

Build a position-independent executable.

A string specifying a DLL name fitting to 8.3 limit on OS/2 of this shared library.

Additional source files. Same as the source varargs.

A string or integer specifying the soversion of this shared library, such as 0. On Linux and Windows this is used to set the soversion (or equivalent) in the filename. For example, if soversion is 4, a Windows DLL will be called foo-4.dll and one of the aliases of the Linux shared library would be libfoo.so.4. If this is not specified, the first part of version is used instead (see below). For example, if version is 3.6.0 and soversion is not defined, it is set to 3.

The actual target type to build

A string specifying the version of this shared library, such as 1.1.0. On Linux and OS X, this is used to set the shared library version in the filename, such as libfoo.so.1.1.0 and libfoo.1.1.0.dylib. If this is not specified, soversion is used instead (see above).

Specify a Microsoft module definition file for controlling symbol exports, etc., on platforms where that is possible (e.g. Windows).

(Since 1.3.0) [@customidx] are supported

Specifies the subsystem type to use on the Windows platform. Typical values include console for text mode programs and windows for gui apps. The value can also contain version specification such as windows,6.0. See [MSDN documentation] for the full list.

glob[both_libs|build_tgt|custom_tgt|file|generated_list|str],
android_exe_type str:,
<lang>_args listify[str]:,
<lang>_pch build_tgt|file|list|str:,
<lang>_shared_args listify[str]:,
<lang>_static_args listify[str]:,
build_by_default bool:,
build_rpath str:,
build_subdir str:,
darwin_versions listify[int|str]:,
dependencies listify[dep]:,
export_dynamic bool:,
extra_files listify[both_libs|build_tgt|custom_tgt|file|str]:,
gnu_symbol_visibility str:,
gui_app bool:,
implib bool|str:,
implicit_include_directories bool:,
include_directories listify[inc|str]:,
install bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_rpath str:,
install_tag str:,
install_vala_gir bool|str:,
install_vala_header bool|str:,
install_vala_vapi bool|str:,
link_args listify[str]:,
link_depends listify[build_tgt|custom_tgt|file|str]:,
link_early_args listify[str]:,
link_language str:,
link_whole listify[both_libs|build_tgt|custom_tgt|file]:,
link_with listify[both_libs|build_tgt|custom_tgt|file]:,
name_prefix list|str:,
name_suffix list|str:,
native bool:,
objects listify[file|str]:,
override_options dict[bool|int|list|str]|list[str]|str:,
pic bool:,
pie bool:,
shortname str:,
sources listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
soversion int|str:,
target_type str:,
version str:,
vs_module_defs custom_tgt|file|str:,
win_subsystem str:,

The name for this build target, followed by an optional list of sources.

Specifies the intended target of the executable. This can either be executable, if the intended usecase is to run the executable using fork + exec, or application if the executable is supposed to be loaded as shared object by the android runtime.

compiler flags to use for the given language; eg: cpp_args for C++

precompiled header file to use for the given language

Arguments that are only passed to a shared library

Arguments that are only passed to a static library

Causes, when set to true, to have this target be built by default. This means it will be built when meson compile is called without any arguments. The default value is true for all built target types.

A string to add to target's rpath definition in the build dir, but which will be removed on install

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

Defines the compatibility version and current version for the dylib on macOS. If an array is specified, it must be either zero, one, or two elements. If only one element is specified or if it's not an array the specified value will be used for setting both compatibility version and current version. If unspecified, the soversion will be used as per the aforementioned rules.

one or more dependency objects created with [dependency] or [compiler.findlibrary] (for external deps) or [declaredependency] (for deps built by the project)

when set to true causes the target's symbols to be dynamically exported, allowing modules built using the [sharedmodule] function to refer to functions, variables and other symbols defined in the executable itself.

Not used for the build itself but are shown as source files in IDEs that group files by targets (such as Visual Studio).

These may only be static sources.

Specifies how symbols should be exported, see e.g [the GCC Wiki] for more information. This value can either be an empty string or one of default, internal, hidden, protected or inlineshidden, which is the same as hidden but also includes things like C++ implicit constructors as specified in the GCC manual. Ignored on compilers that do not support GNU visibility arguments. See also [snippets.symbol_visibility_header()] method to help with defining public API.

When set to true flags this target as a GUI application on platforms where this makes a difference, deprecated since 0.56.0, use win_subsystem instead.

When set to a string, that will be the name of a generated import library.

Since 1.10.0 passing a boolean value is deprecated.

When set to true, an import library is generated for the executable (the name of the import library is based on exename). Alternatively, when set to a string, that gives the base name for the import library. The import library is used when the returned build target object appears in link_with: elsewhere. Only has any effect on platforms where that is meaningful (e.g. Windows). Implies the export_dynamic argument.

Controls whether Meson adds the current source and build directories to the include path

one or more objects created with the [includedirectories] function, or (since 0.50.0) strings, which will be transparently expanded to include directory objects

When set to true, all outputs of this buildtarget will be installed.

override install directory for outputs of this build target. If the value is a relative path, it will be considered relative the prefix option. For example, if you want to install plugins into a subdir, you'd use something like this: install_dir : get_option('libdir') / 'projectname-1.0'.

This can be set to an array of values to control the the installation path of build targets with multiple outputs. Currently, that means Vala. Setting them to true means "use the default", and false means, don't install. By default the first element is true, and all other elements are false.

Since 1.11.0 Passing an array is deprecated, and installvalaheader, installvalavapi, and installvalagir keyword arguments should be used instead.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string to set the target's rpath to after install (but not before that). On Windows, this argument has no effect.

A string used by the meson install --tags command to install only a subset of the files. By default all build targets have the tag runtime except for static libraries that have the devel tag.

If set to a string value, the vala generated gir library will be installed to that path, if set to true, the default gir path will be used, if false the gir library will not be installed.

It is an error for this to be either true or a string and vala_gir to be unset.

The default value is false.

If set to a string value, the vala generated header will be installed to that path, if set to true, the default include path will be used, if false the header will not be installed.

The default value is false.

If set to a string value, the vala generated vapi library will be installed to that path, if set to true, the default vapi path will be used, if false the vapi library will not be installed.

The default value is false.

Flags to use during linking. You can use UNIX-style flags here for all platforms.

Strings, files, or custom targets the link step depends on such as a symbol visibility map. The purpose is to automatically trigger a re-link (but not a re-compile) of the target when this file changes.

Flags to use during linking. These are just like linkargs, except that they are inserted into the linker command line before any object files or libraries. You can use UNIX-style flags here for all platforms. This is only supported when using the Ninja backend.

Makes the linker for this target be for the specified language. It is generally unnecessary to set this, as Meson will detect the right linker to use in most cases. There are only two cases where this is needed. One, your main function in an executable is not in the language Meson picked, or second you want to force a library to use only one ABI.

(broken until 0.55.0)

Links all contents of the given static libraries whether they are used or not, equivalent to the -Wl,--whole-archive argument flag of GCC, or the '/WHOLEARCHIVE' MSVC linker option. This allows the linked target to re-export symbols from all objects in the static libraries.

(since 0.41.0) If passed an array that array will be flattened.

(since 0.51.0) This argument also accepts outputs produced by custom targets. The user must ensure that the output is a library in the correct format.

One or more shared or static libraries (built by this project) that this target should be linked with. (since 0.41.0) If passed an array that array will be flattened. (since 0.51.0) The arguments can also be custom targets. In this case Meson will assume that merely adding the output file in the linker command line is sufficient to make linking work. If this is not sufficient, then the build system writer must write all other steps manually.

The string that will be used as the prefix for the target output filename by overriding the default (only used for libraries). By default this is lib on all platforms and compilers, except for MSVC shared libraries where it is omitted to follow convention, and Cygwin shared libraries where it is cyg.

Set this to [], or omit the keyword argument for the default behaviour.

The string that will be used as the extension for the target by overriding the default. By default on Windows this is exe for executables and on other platforms it is omitted.

For shared libraries, the default value is dylib on macOS, dll on Windows, and so everywhere else. For static libraries, it is a everywhere. By convention MSVC static libraries use the lib suffix, but we use a to avoid a potential name clash with shared libraries which also generate import libraries with a lib suffix.

Set this to [], or omit the keyword argument for the default behaviour.

Controls whether the target is compiled for the build or host machines.

List of object files that should be linked in this target.

Since 1.1.0 this can include generated files in addition to object files that you don't have source to or that object files produced by other build targets. In earlier release, generated object files had to be placed in sources.

takes an array of strings in the same format as project's default_options overriding the values of these options for this target only. (since 1.2.0): A dictionary may now be passed.

Builds the library as positional independent code (so it can be linked into a shared library). This option has no effect on Windows and OS X since it doesn't make sense on Windows and PIC cannot be disabled on OS X.

Build a position-independent executable.

A string specifying a DLL name fitting to 8.3 limit on OS/2 of this shared library.

Additional source files. Same as the source varargs.

A string or integer specifying the soversion of this shared library, such as 0. On Linux and Windows this is used to set the soversion (or equivalent) in the filename. For example, if soversion is 4, a Windows DLL will be called foo-4.dll and one of the aliases of the Linux shared library would be libfoo.so.4. If this is not specified, the first part of version is used instead (see below). For example, if version is 3.6.0 and soversion is not defined, it is set to 3.

The actual target type to build

A string specifying the version of this shared library, such as 1.1.0. On Linux and OS X, this is used to set the shared library version in the filename, such as libfoo.so.1.1.0 and libfoo.1.1.0.dylib. If this is not specified, soversion is used instead (see above).

Specify a Microsoft module definition file for controlling symbol exports, etc., on platforms where that is possible (e.g. Windows).

(Since 1.3.0) [@customidx] are supported

Specifies the subsystem type to use on the Windows platform. Typical values include console for text mode programs and windows for gui apps. The value can also contain version specification such as windows,6.0. See [MSDN documentation] for the full list.

glob[both_libs|build_tgt|custom_tgt|file|generated_list|str],
android_exe_type str:,
<lang>_args listify[str]:,
<lang>_pch build_tgt|file|list|str:,
<lang>_shared_args listify[str]:,
<lang>_static_args listify[str]:,
build_by_default bool:,
build_rpath str:,
build_subdir str:,
darwin_versions listify[int|str]:,
dependencies listify[dep]:,
export_dynamic bool:,
extra_files listify[both_libs|build_tgt|custom_tgt|file|str]:,
gnu_symbol_visibility str:,
gui_app bool:,
implib bool|str:,
implicit_include_directories bool:,
include_directories listify[inc|str]:,
install bool:,
install_dir str:,
install_mode listify[bool|int|str]:,
install_rpath str:,
install_tag str:,
install_vala_gir bool|str:,
install_vala_header bool|str:,
install_vala_vapi bool|str:,
link_args listify[str]:,
link_depends listify[build_tgt|custom_tgt|file|str]:,
link_early_args listify[str]:,
link_language str:,
link_whole listify[both_libs|build_tgt|custom_tgt|file]:,
link_with listify[both_libs|build_tgt|custom_tgt|file]:,
name_prefix list|str:,
name_suffix list|str:,
native bool:,
objects listify[file|str]:,
override_options dict[bool|int|list|str]|list[str]|str:,
pic bool:,
pie bool:,
shortname str:,
sources listify[both_libs|build_tgt|custom_tgt|file|generated_list|str]:,
soversion int|str:,
target_type str:,
version str:,
vs_module_defs custom_tgt|file|str:,
win_subsystem str:,

The name for this build target, followed by an optional list of sources.

Specifies the intended target of the executable. This can either be executable, if the intended usecase is to run the executable using fork + exec, or application if the executable is supposed to be loaded as shared object by the android runtime.

compiler flags to use for the given language; eg: cpp_args for C++

precompiled header file to use for the given language

Arguments that are only passed to a shared library

Arguments that are only passed to a static library

Causes, when set to true, to have this target be built by default. This means it will be built when meson compile is called without any arguments. The default value is true for all built target types.

A string to add to target's rpath definition in the build dir, but which will be removed on install

Places the build results in a subdirectory of the given name rather than directly into the build directory. This does not affect the install directory, which uses installdir. This allows inserting a directory name into the build path, either when needed to use the build result while building other targets or as a way to support multiple targets with the same basename by using unique buildsubdir values for each one. To prevent collisions within the build directory, buildsubdir is not allowed to match a file or directory in the source directory, nor contain '..' to refer to the parent of the build directory.

Defines the compatibility version and current version for the dylib on macOS. If an array is specified, it must be either zero, one, or two elements. If only one element is specified or if it's not an array the specified value will be used for setting both compatibility version and current version. If unspecified, the soversion will be used as per the aforementioned rules.

one or more dependency objects created with [dependency] or [compiler.findlibrary] (for external deps) or [declaredependency] (for deps built by the project)

when set to true causes the target's symbols to be dynamically exported, allowing modules built using the [sharedmodule] function to refer to functions, variables and other symbols defined in the executable itself.

Not used for the build itself but are shown as source files in IDEs that group files by targets (such as Visual Studio).

These may only be static sources.

Specifies how symbols should be exported, see e.g [the GCC Wiki] for more information. This value can either be an empty string or one of default, internal, hidden, protected or inlineshidden, which is the same as hidden but also includes things like C++ implicit constructors as specified in the GCC manual. Ignored on compilers that do not support GNU visibility arguments. See also [snippets.symbol_visibility_header()] method to help with defining public API.

When set to true flags this target as a GUI application on platforms where this makes a difference, deprecated since 0.56.0, use win_subsystem instead.

When set to a string, that will be the name of a generated import library.

Since 1.10.0 passing a boolean value is deprecated.

When set to true, an import library is generated for the executable (the name of the import library is based on exename). Alternatively, when set to a string, that gives the base name for the import library. The import library is used when the returned build target object appears in link_with: elsewhere. Only has any effect on platforms where that is meaningful (e.g. Windows). Implies the export_dynamic argument.

Controls whether Meson adds the current source and build directories to the include path

one or more objects created with the [includedirectories] function, or (since 0.50.0) strings, which will be transparently expanded to include directory objects

When set to true, all outputs of this buildtarget will be installed.

override install directory for outputs of this build target. If the value is a relative path, it will be considered relative the prefix option. For example, if you want to install plugins into a subdir, you'd use something like this: install_dir : get_option('libdir') / 'projectname-1.0'.

This can be set to an array of values to control the the installation path of build targets with multiple outputs. Currently, that means Vala. Setting them to true means "use the default", and false means, don't install. By default the first element is true, and all other elements are false.

Since 1.11.0 Passing an array is deprecated, and installvalaheader, installvalavapi, and installvalagir keyword arguments should be used instead.

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string to set the target's rpath to after install (but not before that). On Windows, this argument has no effect.

A string used by the meson install --tags command to install only a subset of the files. By default all build targets have the tag runtime except for static libraries that have the devel tag.

If set to a string value, the vala generated gir library will be installed to that path, if set to true, the default gir path will be used, if false the gir library will not be installed.

It is an error for this to be either true or a string and vala_gir to be unset.

The default value is false.

If set to a string value, the vala generated header will be installed to that path, if set to true, the default include path will be used, if false the header will not be installed.

The default value is false.

If set to a string value, the vala generated vapi library will be installed to that path, if set to true, the default vapi path will be used, if false the vapi library will not be installed.

The default value is false.

Flags to use during linking. You can use UNIX-style flags here for all platforms.

Strings, files, or custom targets the link step depends on such as a symbol visibility map. The purpose is to automatically trigger a re-link (but not a re-compile) of the target when this file changes.

Flags to use during linking. These are just like linkargs, except that they are inserted into the linker command line before any object files or libraries. You can use UNIX-style flags here for all platforms. This is only supported when using the Ninja backend.

Makes the linker for this target be for the specified language. It is generally unnecessary to set this, as Meson will detect the right linker to use in most cases. There are only two cases where this is needed. One, your main function in an executable is not in the language Meson picked, or second you want to force a library to use only one ABI.

(broken until 0.55.0)

Links all contents of the given static libraries whether they are used or not, equivalent to the -Wl,--whole-archive argument flag of GCC, or the '/WHOLEARCHIVE' MSVC linker option. This allows the linked target to re-export symbols from all objects in the static libraries.

(since 0.41.0) If passed an array that array will be flattened.

(since 0.51.0) This argument also accepts outputs produced by custom targets. The user must ensure that the output is a library in the correct format.

One or more shared or static libraries (built by this project) that this target should be linked with. (since 0.41.0) If passed an array that array will be flattened. (since 0.51.0) The arguments can also be custom targets. In this case Meson will assume that merely adding the output file in the linker command line is sufficient to make linking work. If this is not sufficient, then the build system writer must write all other steps manually.

The string that will be used as the prefix for the target output filename by overriding the default (only used for libraries). By default this is lib on all platforms and compilers, except for MSVC shared libraries where it is omitted to follow convention, and Cygwin shared libraries where it is cyg.

Set this to [], or omit the keyword argument for the default behaviour.

The string that will be used as the extension for the target by overriding the default. By default on Windows this is exe for executables and on other platforms it is omitted.

For shared libraries, the default value is dylib on macOS, dll on Windows, and so everywhere else. For static libraries, it is a everywhere. By convention MSVC static libraries use the lib suffix, but we use a to avoid a potential name clash with shared libraries which also generate import libraries with a lib suffix.

Set this to [], or omit the keyword argument for the default behaviour.

Controls whether the target is compiled for the build or host machines.

List of object files that should be linked in this target.

Since 1.1.0 this can include generated files in addition to object files that you don't have source to or that object files produced by other build targets. In earlier release, generated object files had to be placed in sources.

takes an array of strings in the same format as project's default_options overriding the values of these options for this target only. (since 1.2.0): A dictionary may now be passed.

Builds the library as positional independent code (so it can be linked into a shared library). This option has no effect on Windows and OS X since it doesn't make sense on Windows and PIC cannot be disabled on OS X.

Build a position-independent executable.

A string specifying a DLL name fitting to 8.3 limit on OS/2 of this shared library.

Additional source files. Same as the source varargs.

A string or integer specifying the soversion of this shared library, such as 0. On Linux and Windows this is used to set the soversion (or equivalent) in the filename. For example, if soversion is 4, a Windows DLL will be called foo-4.dll and one of the aliases of the Linux shared library would be libfoo.so.4. If this is not specified, the first part of version is used instead (see below). For example, if version is 3.6.0 and soversion is not defined, it is set to 3.

The actual target type to build

A string specifying the version of this shared library, such as 1.1.0. On Linux and OS X, this is used to set the shared library version in the filename, such as libfoo.so.1.1.0 and libfoo.1.1.0.dylib. If this is not specified, soversion is used instead (see above).

Specify a Microsoft module definition file for controlling symbol exports, etc., on platforms where that is possible (e.g. Windows).

This can be used to expose which functions a sharedmodule loaded by an executable will be allowed to use.

Specifies the subsystem type to use on the Windows platform. Typical values include console for text mode programs and windows for gui apps. The value can also contain version specification such as windows,6.0. See [MSDN documentation] for the full list.

str,
if_found listify[dep]:,

Directory relative to the current meson.build to enter.

Cannot contain ..

Only enter the subdir if all [dep.found] methods return true.

str,
default_options dict[bool|int|list|str]|list[str]|str:,
required bool|feature:,
version listify[str]:,

Name of the subproject. The subproject must exist in the subprojects directory (or the directory specified in the subproject_dir of [project]) as a directory or wrap file.

An array of default option values that override those set in the subproject's meson.options (like default_options in [project], they only have effect when Meson is run for the first time, and command line arguments override any default options in build files). (since 0.54.0): default_library built-in option can also be overridden. (since 1.2.0): A dictionary may now be passed.

Works just the same as in [dependency].

Works just like the same as in [dependency]. It specifies what version the subproject should be, as an example >=1.0.1.

dict[bool|dep|external_program|feature|int|str|list[bool|dep|external_program|feature|int|str]]|str,
bool|dep|external_program|feature|int|str|list[bool|dep|external_program|feature|int|str],
bool_yn bool:,
list_sep str:,
section str:,

The name of the new entry, or a dict containing multiple entries. If a dict is passed it is equivalent to calling summary() once for each key-value pair. Keep in mind that dictionaries do not guarantee ordering.

The value to print for the key. Only valid if key_or_dict is a str.

Convert bool values to yes and no

The separator to use when printing array values in this summary. If no separator is given, each array item will be printed on its own line.

The section to put this summary information under. If the section keyword argument is omitted, key/value pairs are implicitly grouped into a section with no title.

str,
build_tgt|custom_tgt|external_program|file|python_installation,
args listify[exe]:,
depends listify[both_libs|build_tgt|custom_tgt|file]:,
env dict[listify[str]]|env|listify[str]:,
expected_exitcode int:,
expected_fail bool:,
is_parallel bool:,
priority int:,
protocol str:,
should_fail bool:,
suite listify[str]:,
timeout int:,
verbose bool:,
workdir str:,

nomalloc = environment({'MALLOC_PERTURB_': '0'})
test(..., env: nomalloc, ...)

The unique test id

The program to execute. (Since 1.4.0) A CustomTarget is also accepted.

Arguments to pass to the executable

specifies that this test depends on the specified target(s), even though it does not take any of them as a command line argument. This is meant for cases where test finds those targets internally, e.g. plugins or globbing. Those targets are built before test is executed even if they have build_by_default : false.

environment variables to set, such as ['NAME1=value1', 'NAME2=value2'], or an [@env] object which allows more sophisticated environment juggling. (Since 0.52.0) A dictionary is also accepted.

the test is considered passed if the executable returns the specified returncode, only has effect when protocol is set to exitcode

when true the test is considered passed if the executable returns a non-zero return value (i.e. reports an error)

when false, specifies that no other test must be running at the same time as this test

specifies the priority of a test. Tests with a higher priority are started before tests with a lower priority. The starting order of tests with identical priorities is implementation-defined. The default priority is 0, negative numbers are permitted.

specifies how the test results are parsed and can be one of exitcode, tap, or gtest. For more information about test harness protocol read [Unit Tests]. The following values are accepted:

• exitcode: the executable's exit code is used by the test harness to record the outcome of the test).
• tap: [Test Anything Protocol].
• gtest (since 0.55.0): for Google Tests.
• rust (since 0.56.0): for native rust tests

when true the test is considered passed if the executable returns a non-zero return value (i.e. reports an error)

the amount of seconds the test is allowed to run, a test that exceeds its time limit is always considered failed, defaults to 30 seconds. Since 0.57 if timeout is <= 0 the test has infinite duration, in previous versions of Meson the test would fail with a timeout immediately.

if true, forces the test results to be logged as if --verbose was passed to meson test.

absolute path that will be used as the working directory for the test

any|null,

str,

The variable to unset.

command listify[exe]:,
fallback str:,
input listify[both_libs|build_tgt|custom_tgt|file|str]:,
install bool:,
install_dir listify[bool|str]:,
install_mode listify[bool|int|str]:,
install_tag str:,
output str:,
replace_string str:,

The command to execute, see [customtarget] for details on how this command must be specified.

This parameter is optional. If it is absent, Meson will try its best to find a suitable default command.

(since 0.62.0) [@file] is accepted.

(since 0.63.0) [@customtgt], [@exe], and [@program] are accepted.

Version number to use when no revision control information is present, such as when building from a release tarball.

File to modify (e.g. version.c.in).

When true, this generated file is installed during the install step, and install_dir must be set and not empty.

The subdirectory to install the generated file to (e.g. share/myproject).

Specify the file mode in symbolic format and optionally the owner/uid and group/gid for the installed files.

See the install_mode kwarg of [installdata] for more information.

A string used by the meson install --tags command to install only a subset of the files. By default the file has no install tag which means it is not being installed when --tags argument is specified.

File to write the results to (e.g. version.c).

String in the input file to substitute with the commit information.

glob[bool|dict|feature|file|int|list|str],

The message to print.

str,
str,

The string to return when the boolean is true

The string to return when the boolean is false

recursive bool:,

glob[custom_tgt|file|generated_list|str],

dict,

accepted properties: .nf

str

dict,

accepted properties: .nf

setproperties

recursive bool:,

Also return objects passed to the objects argument of this target.

glob[custom_tgt|file|generated_list|str],

Source filenames for which the built objects should be extracted.

str,
any,

The name of the variable to query

The default value to return when varname does not exist

str,
any,

The name of the variable to query

The default value to return when varname does not exist

str,

The name of the variable to query

cfg_data,

The other [@cfgdata] object to merge into this one.

str,
bool|int|str,
description str:,

The name of the variable to set

The value to set

Message / Comment that will be written in the result file. The replacement assumes a file with C syntax. If your generated file is source code in some other language, you probably don't want to add a description field because it most likely will cause a syntax error.

str,
bool,
description str:,

The name of the variable to set

The value to set as either 1 or 0

Passing numbers was never intended to work, and since 0.62 it has been deprecated. It will be removed in a future version of Meson. If you need to pass numbers use the .set method.

Message / Comment that will be written in the result file. The replacement assumes a file with C syntax. If your generated file is source code in some other language, you probably don't want to add a description field because it most likely will cause a syntax error.

str,
str,
description str:,

The name of the variable to set

The value to set

Message / Comment that will be written in the result file. The replacement assumes a file with C syntax. If your generated file is source code in some other language, you probably don't want to add a description field because it most likely will cause a syntax error.

str,
args listify[str]:,
dependencies listify[dep]:,
guess int:,
high int:,
include_directories listify[inc|str]:,
low int:,
name str:,
prefix listify[str]:,
required bool|feature:,
werror bool:,

The name of the type to check.

Used to pass an array of compiler arguments. Defining include paths for headers not in the default include path via -Isome/path/to/header is generally supported, however, usually not recommended.

This is because include directories can also be specified via the include_directories or the dependency kwarg (if present). The same is also true for passing libraries to link with -lfoo.

Additionally dependencies required for compiling and / or linking.

one or more objects created with the [includedirectories] function, or (since 0.50.0) strings, which will be transparently expanded to include directory objects

Used to add #includes and other things that are required for the symbol to be declared. Since 1.0.0 an array is accepted too. When an array is passed, the items are concatenated together separated by a newline. System definitions should be passed via compiler args (eg: _GNU_SOURCE is often required for some symbols to be exposed on Linux, and it should be passed via args keyword argument).

str,
args listify[str]:,
dependencies listify[dep]:,
guess int:,
high int:,
include_directories listify[inc|str]:,
low int:,
name str:,
prefix listify[str]:,
required bool|feature:,
werror bool:,

The header to check.

Used to pass an array of compiler arguments. Defining include paths for headers not in the default include path via -Isome/path/to/header is generally supported, however, usually not recommended.

This is because include directories can also be specified via the include_directories or the dependency kwarg (if present). The same is also true for passing libraries to link with -lfoo.

Additionally dependencies required for compiling and / or linking.

Extra directories for header searches, created with the [includedirectories] function. (Since 1.10.0) Strings are also accepted.

Used to add #includes and other things that are required for the symbol to be declared. Since 1.0.0 an array is accepted too. When an array is passed, the items are concatenated together separated by a newline. System definitions should be passed via compiler args (eg: _GNU_SOURCE is often required for some symbols to be exposed on Linux, and it should be passed via args keyword argument).

When set to true, Meson will halt if the header check fails. When set to a [feature] option, the feature will control if it is searched and whether to fail if not found.

file|str,
args listify[str]:,
dependencies listify[dep]:,
guess int:,
high int:,
include_directories listify[inc|str]:,
low int:,
name str:,
prefix listify[str]:,
required bool|feature:,
werror bool:,

The source code to check.

If a string is passed, the code is used directly. If a [@file] object is passed, its content is used for the compiler check.

Used to pass an array of compiler arguments. Defining include paths for headers not in the default include path via -Isome/path/to/header is generally supported, however, usually not recommended.

This is because include directories can also be specified via the include_directories or the dependency kwarg (if present). The same is also true for passing libraries to link with -lfoo.

Additionally dependencies required for compiling and / or linking.

Extra directories for header searches, created with the [includedirectories] function. (Since 1.10.0) Strings are also accepted.

The name to use for printing a message about the compiler check. If this keyword argument is not passed, no message will be printed about the check.

When set to true, Meson will halt if the check fails. When set to a [feature] option, the feature will control if it is searched and whether to fail if not found.

When set to true, compiler warnings are treated as error.

str,
args listify[str]:,
dependencies listify[dep]:,
guess int:,
high int:,
include_directories listify[inc|str]:,
low int:,
name str:,
prefix listify[str]:,
required bool|feature:,
werror bool:,

The expression to compute.

Used to pass an array of compiler arguments. Defining include paths for headers not in the default include path via -Isome/path/to/header is generally supported, however, usually not recommended.

This is because include directories can also be specified via the include_directories or the dependency kwarg (if present). The same is also true for passing libraries to link with -lfoo.

Additionally dependencies required for compiling and / or linking.

The value to try first.

The max value.

Extra directories for header searches, created with the [includedirectories] function. (Since 1.10.0) Strings are also accepted.

The min value.

Used to add #includes and other things that are required for the symbol to be declared. Since 1.0.0 an array is accepted too. When an array is passed, the items are concatenated together separated by a newline. System definitions should be passed via compiler args (eg: _GNU_SOURCE is often required for some symbols to be exposed on Linux, and it should be passed via args keyword argument).

str[archiver|compiler|linker],
cmd_array listify[str]:,
handlers dict[bool|function|list[str]]:,
libdirs listify[str]:,
overwrite bool:,
version str:,

str,
dirs listify[str]:,
disabler bool:,
has_headers listify[str]:,
header_args listify[str]:,
header_dependencies listify[dep]:,
header_include_directories listify[inc|str]:,
header_no_builtin_args null:,
header_prefix null:,
header_required bool:,
required bool|feature:,
static bool:,

The library to find.

Additional directories to search in.

By default the library is searched for in the system library directory (e.g. /usr/lib). Specifying more directories here, causes Meson to search in those directories as well as the system directories.

If true, this method will return a [@disabler] on a failed check.

An array of headers that must be found as well. This check is equivalent to checking each header with a [compiler.hasheader] call.

When used, kwargs that [compiler.hasheader] would accept can be passed here prefixed with header_, and will have the same effect on the header check.

When the has_headers kwarg is also used, this argument is passed to [compiler.hasheader] as args.

When the has_headers kwarg is also used, this argument is passed to [compiler.hasheader] as dependencies.

When the has_headers kwarg is also used, this argument is passed to [compiler.hasheader] as include_directories. (Since 1.10.0) Strings are also accepted.

When the has_headers kwarg is also used, this argument is passed to [compiler.hasheader] as no_builtin_args.

When the has_headers kwarg is also used, this argument is passed to [compiler.hasheader] as prefix.

When used in conjunction with the hasheaders keyword, set the requirement of the headers.

If set true, Meson will abort with an error if the library could not be found. Otherwise, Meson will continue and the found method of the returned object will return false.

When set to a [feature] option, the feature will control if it is searched and whether to fail if not found.

(since 0.47.0) The value of a feature option can also be passed here.

If true, the search is limited to static libraries only. Setting this value to false (the default) will search for both shared and static libraries.

glob[str],

The arguments to check.

glob[str],

The link arguments to check.

str,
args listify[str]:,
dependencies listify[dep]:,
guess int:,
high int:,
include_directories listify[inc|str]:,
low int:,
name str:,
prefix listify[str]:,
required bool|feature:,
werror bool:,

The define to check.

Used to pass an array of compiler arguments. Defining include paths for headers not in the default include path via -Isome/path/to/header is generally supported, however, usually not recommended.

This is because include directories can also be specified via the include_directories or the dependency kwarg (if present). The same is also true for passing libraries to link with -lfoo.

Additionally dependencies required for compiling and / or linking.

Extra directories for header searches, created with the [includedirectories] function. (Since 1.10.0) Strings are also accepted.

Used to add #includes and other things that are required for the symbol to be declared. Since 1.0.0 an array is accepted too. When an array is passed, the items are concatenated together separated by a newline. System definitions should be passed via compiler args (eg: _GNU_SOURCE is often required for some symbols to be exposed on Linux, and it should be passed via args keyword argument).

glob[str],

The arguments to check.

glob[str],

glob[str],

The link arguments to check.

str,
required bool|feature:,

The argument to check.

When set to true, Meson will halt if the check fails. When set to a [feature] option, the feature will control if it is searched and whether to fail if not found.

str,
args listify[str]:,
dependencies listify[dep]:,
guess int:,
high int:,
include_directories listify[inc|str]:,
low int:,
name str:,
prefix listify[str]:,
required bool|feature:,
werror bool:,

The define to check.

Used to pass an array of compiler arguments. Defining include paths for headers not in the default include path via -Isome/path/to/header is generally supported, however, usually not recommended.

This is because include directories can also be specified via the include_directories or the dependency kwarg (if present). The same is also true for passing libraries to link with -lfoo.

Additionally dependencies required for compiling and / or linking.

Extra directories for header searches, created with the [includedirectories] function. (Since 1.10.0) Strings are also accepted.

Used to add #includes and other things that are required for the symbol to be declared. Since 1.0.0 an array is accepted too. When an array is passed, the items are concatenated together separated by a newline. System definitions should be passed via compiler args (eg: _GNU_SOURCE is often required for some symbols to be exposed on Linux, and it should be passed via args keyword argument).

str,
args listify[str]:,
dependencies listify[dep]:,
guess int:,
high int:,
include_directories listify[inc|str]:,
low int:,
name str:,
prefix listify[str]:,
required bool|feature:,
werror bool:,

The function to check.

Used to pass an array of compiler arguments. Defining include paths for headers not in the default include path via -Isome/path/to/header is generally supported, however, usually not recommended.

This is because include directories can also be specified via the include_directories or the dependency kwarg (if present). The same is also true for passing libraries to link with -lfoo.

Additionally dependencies required for compiling and / or linking.

Extra directories for header searches, created with the [includedirectories] function. (Since 1.10.0) Strings are also accepted.

Used to add #includes and other things that are required for the symbol to be declared. Since 1.0.0 an array is accepted too. When an array is passed, the items are concatenated together separated by a newline. System definitions should be passed via compiler args (eg: _GNU_SOURCE is often required for some symbols to be exposed on Linux, and it should be passed via args keyword argument).

When set to true, Meson will halt if the check fails. When set to a [feature] option, the feature will control if it is searched and whether to fail if not found.

str,
required bool|feature:,

The attribute name to check.

When set to true, Meson will halt if the check fails. When set to a [feature] option, the feature will control if it is searched and whether to fail if not found.

str,
args listify[str]:,
dependencies listify[dep]:,
guess int:,
high int:,
include_directories listify[inc|str]:,
low int:,
name str:,
prefix listify[str]:,
required bool|feature:,
werror bool:,

The header to check.

Used to pass an array of compiler arguments. Defining include paths for headers not in the default include path via -Isome/path/to/header is generally supported, however, usually not recommended.

This is because include directories can also be specified via the include_directories or the dependency kwarg (if present). The same is also true for passing libraries to link with -lfoo.