qt_add_executable | Qt Core | Qt 6.10.1
Description: Creates and finalizes an application target of a platform-specific type.

- Qt 6.10
- Qt Core
- CMake Commands in Qt6 Core
- qt_add_executable
- Qt 6.10.1 Reference Documentation

# qt_add_executable

Creates and finalizes an application target of a platform-specific type.

The command is defined in the `Core` component of the `Qt6` package, which can be loaded like so:

     find_package(Qt6 REQUIRED COMPONENTS Core)

This command was introduced in Qt 6.0.

## Synopsis

     qt_add_executable(target
                       [WIN32] [MACOSX_BUNDLE]
                       [MANUAL_FINALIZATION]
                       sources...)

If versionless commands are disabled, use `qt6_add_executable()` instead. It supports the same set of arguments as this command.

## Description

This command performs the following tasks:

- Create a CMake target of the appropriate type for the target platform.
- Link the target to the `Qt::Core` library.
- Handle finalization of the CMake target.

### Target Creation

On all platforms except Android, an executable target will be created. All arguments will be passed through to the standard CMake `add_executable()` command, except `MANUAL_FINALIZATION` (if present). On Android, a `MODULE` library will be created and any `WIN32` or `MACOSX_BUNDLE` options will be ignored. Some target properties will also be set for Android:

- The `SUFFIX` target property will be set to give the library file name an architecture-specific suffix.
- Various `<lang>_VISIBILITY_PRESET` target properties will be set to `default` to ensure that the `main()` function is visible in the resultant binary.

### Linking Qt::Core

Since all Qt applications need to link to the `Qt::Core` library, this is done for you as a convenience.

### Finalization

After a target is created, further processing or finalization steps are commonly needed. The steps to perform depend on the platform and on various properties of the target.

The finalization processing is implemented by two commands: qt_finalize_target() and qt_finalize_project().

Target finalization can occur either as part of calling `qt_add_executable` or be deferred to sometime after this command returns (but it should still be in the same directory scope).

When using CMake 3.19 or later, target finalization is automatically deferred to the end of the current directory scope. This gives the caller an opportunity to modify properties of the created target before it is finalized. When using CMake versions earlier than 3.19, automatic deferral isn't supported. In that case, target finalization is performed immediately before this command returns.

Regardless of the CMake version, the `MANUAL_FINALIZATION` keyword can be given to indicate that you will explicitly call qt_finalize_target() yourself instead at some later time. In general, `MANUAL_FINALIZATION` should not be needed unless the project has to support CMake 3.18 or earlier.

Project finalization occurs automatically when using CMake 3.19 or later. When using an older CMake version, you should call qt_finalize_project() manually, at the end of the root `CMakeLists.txt` file. This is especially important when targeting Android, to collect dependencies between project targets for deployment purposes.

## Examples

In the following simple case, finalization is handled automatically. If using a CMake version earlier than 3.19, finalization will be performed immediately as part of the call. When using CMake 3.19 or later, finalization will occur at the end of the current directory scope.

     qt_add_executable(simpleapp main.cpp)

The following example shows a scenario where finalization must be deferred. The `OUTPUT_NAME` target property affects deployment settings on Android, but those settings are written out as part of finalizing the target. In order to support using CMake versions earlier than 3.19, we take over responsibility for finalizing the target by adding the `MANUAL_FINALIZATION` keyword.

     qt_add_executable(complexapp MANUAL_FINALIZATION complex.cpp)
     set_target_properties(complexapp PROPERTIES OUTPUT_NAME Complexify)
     qt_finalize_target(complexapp)

Warning: If your Android project is built using a CMake version lower than 3.19, make sure that you call qt6_finalize_project() at the end of a top-level CMakeLists.txt.

See also qt_finalize_target(), qt_set_finalizer_mode(), qt_add_library(), and qt_finalize_project().