New features (in development)

BuildTarget(install_dir) length > 1 replaced with keywords

Build Targets currently support (with limited documentation), passing an array of more than one element to install_dir: (except for in some wrappers), and will map these additional install_dir's to extra outputs. This is only used by vala, and has been replaced by explicit keyword arguments.

Code like this:

library(
  'foo',
  'foo.vala',
  install : true,
  install_dir : [true, get_option('includedir') / 'foo', true],
)

should now be written as the much clearer:

library(
  'foo',
  'foo.vala',
  install : true,
  install_vala_header_dir : get_option('includedir') / 'foo
)

Note that now you only need to specify values you want to deviate from the default.

Cargo workspace object

Meson now is able to parse the toplevel Cargo.toml file of the project when the workspace() method of the Rust module is called. This guarantees that features are resolved according to what is in the Cargo.toml file, and in fact enables configuration of features for the build.

The returned object also allows retrieving features and dependencies for Cargo subprojects.

While Cargo subprojects remain experimental, the Meson project will try to keep the workspace object reasonably backwards-compatible.

Cython no longer requires explicitly enabling C or C++

This only provides these languages as an implementation detail of Cython, so native C/C++ targets cannot be compiled.

Deduplication of OpenMP linker arguments

Meson now deduplicates linker arguments -fopenmp and -qopenmp.

meson dist now accepts -j/--num-processes

meson dist now supports a -j/--num-processes flag to control the number of parallel processes used during the distribution check (compilation and testing of the generated package). The MESON_NUM_PROCESSES environment variable is also honored, consistent with other Meson commands.

Deprecate should_fail and rename it to expected_fail, also introduce expected_exitcode

In 1.11.0 should_fail has been renamed to expected_error.

Before 1.11.0, there was no way to positively test a command/binary returning error/non-zero exit code when the used protocol was set to exitcode, so expected_exitcode has been introduced to achieve this. Do note that if the exitcode does not match the expected value, GNU skip and exit codes are still valid and the test result may be skip or error.

The external_project module uses the cygpath command to convert paths

In previous versions, the external_project module on Windows used a Windows-style path (e.g., C:/path/to/configure) to execute the configure file, and a relative path from the drive root (e.g., /path/to/prefix) as the installation prefix. However, since configure scripts are typically intended to be run in a POSIX-like environment (MSYS2, Cygwin, or GitBash), these paths were incompatible with some configure scripts.

The external_project module now uses the cygpath command to convert the configure command path and prefix to Unix-style paths (e.g., /c/path/to/configure for MSYS2 and /cygdrive/c/path/to/configure for Cygwin). If the cygpath command is not found in the PATH, it will fall back to the previous behavior.

install_man and install_headers: add support for install_tag kwarg

install_man and install_headers now support the install_tag keyword argument, allowing selection of installed files via meson install --tags. Previously, install_man always used the man tag and install_headers always used the devel tag, with no way to override them.

Added link_early_args to targets performing linking

Options passed to the linker using the link_args keyword argument get placed on the command line after all objects and libraries. Some linker options, like -u or --defsym, are only useful if placed before objects and libraries as they control how the linker manipulates those.

The new link_early_args keyword argument passes linker options which are inserted into the command line before any objects and libraries allowing applications to use these kinds of linker options with meson.

This is currently only supported when using the ninja backend.

Machine files now expand ~ as the user's home directory

A new constant ~ has been added which can be used in machine files (native and cross files) to refer to the user's home directory. This is useful for specifying paths to SDKs and toolchains that are commonly installed into ~, such as Qt, the Android SDK/NDK, or user-installed frameworks on macOS:

[constants]
toolchain = ~ / 'Android/sdk/ndk/27.1.12297006/toolchains/llvm/prebuilt/linux-x86_64'

[binaries]
c = toolchain / 'bin/clang'
cpp = toolchain / 'bin/clang++'
ar = toolchain / 'bin/llvm-ar'

Note that ~ can be used anywhere in the machine file. In the above example, the purpose of defining a new constant called toolchain is to not have to repeat yourself when using the path multiple times.

-Db_lto and -Db_pgo now supported for MSVC

-Db_lto is now supported for MSVC's /LTCG, as is -Db_lto_mode=thin for /LTCG:INCREMENTAL. -Db_pgo is also supported, and should be used alongside -Db_lto=true.

Last major version supporting Python 3.7, 3.8, and 3.9

Python older than 3.10 is now EOL, and Meson will drop support for these versions in the next major release, and will freely use features from 3.8, 3.9 and 3.10. Support for these versions will remain for the 1.11.x series.

Python extension modules default to C ABI for Rust

py.extension_module() now defaults rust_abi to 'c', so that Rust extension modules produce a cdylib instead of a dylib. This is the correct crate type for Python extension modules written in Rust, and previously had to be specified manually via rust_crate_type: 'cdylib' or rust_abi: 'c'.

meson now defines QT_DEBUG or QT_NO_DEBUG depending on build type

When using the qt meson modules, the QT_DEBUG or QT_NO_DEBUG preprocessor macro is now set depending on the value of the debug built-in meson option. This mimicks the behavior of qmake, and is expected by the <QtGlobal> header.

Change to handling of linker arguments for Rust

Since the Rust compiler integrates the compiler and linker phase, previous Meson versions did not obey link_args, add_project_link_arguments or add_global_link_arguments.

Starting in this version, add_project_link_arguments(), add_global_link_arguments(), and the link_args keyword argument are supported for Rust. They wrap the arguments with -Clink-arg= when invoking rustc, and are only included when creating binary or shared library crates.

Likewise, methods such as has_link_argument() now wrap the arguments being tested with -Clink-arg=.

XC32 support now aware of v5.00 features

XC32 features introduced in v5.00 can now be used. This includes support for LTO auto and the C2x and CPP23 standards.

windows.compile_resources now detects header changes with rc.exe

The rc.exe resource compiler neither provides depfile support nor allows showing includes, as is possible with C or C++ compilers. Therefore, changes to files included by the .rc file did not trigger recompilation of the resource file.

A workaround was added to meson by calling the preprocessor on the .rc file to display the included headers and allow ninja to record them as dependencies.

Added implicit_include_directories argument to windows.compile_resources

Windows module compile_resources now have a implicit_include_directories keyword argument to automatically add current build and source directories to the included paths when compiling a resource.