Qt Documentation

Contents

Qt’s support for different Windows platforms is extensive and mature.

Before you get started, ensure that your development environment fulfills the requirements.

To download and install Qt for Windows, follow the instructions on the Getting Started with Qt page.

Supported Configurations

The following configurations are supported.

Operating System	Architecture	Compiler	Notes
Windows 10	x86 and x86_64	MSVC 2019, MSVC 2017, MSVC 2015, MinGW 8.1
Windows 8.1	x86 and x86_64	MSVC 2019, MSVC 2017, MinGW 8.1
Windows 7	x86 and x86_64	MSVC 2019, MSVC 2017, MinGW 8.1	MinGW-builds GCC 8.1.0 (x86)

Deployment and Other Issues

The pages below covers specific issues and recommendations for creating Windows applications.

Where to Go from Here

We invite you to explore the rest of Qt. We prepared overviews which help you decide which APIs to use and our examples demonstrate how to use our API.

• Qt Overviews — list of topics about application development
• Examples and Tutorials — code samples and tutorials
• Qt Reference Pages — a listing of C++ and QML APIs
• ActiveX in Qt

Qt’s vibrant and active community site, http://qt.io houses a wiki, a forum, and additional learning guides and presentations.

Visual Studio Tools

The Qt VS Tools allows programmers to create, build, debug and run Qt applications from within non-Express versions of Microsoft Visual Studio 2013 and later. The add-in contains project wizards, Qt project import/export support, integrated Qt resource manager and automated build setup for the Qt Meta-Object Compiler, User Interface Compiler, and Resource Compiler.

В© 2021 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

Статическая линковка библиотек Qt 5.x (MinGW) под Windows

В данной статье я опишу как сделать отдельный комплект со статической линковкой библиотек Qt5. Если другими словами, мы сможем собирать проект в один исполняемый файл без Qt *.dll.

Подготовка

Начнем

Сборка комплекта

• Создаем резервную копию qmake.conf, он находится в «Qt5.5.0\5.5\mingw492_32\mkspecs\win32-g++»
• Делаем изменения в qmake.conf
• Создаем резервную копию исходников Qt, они находятся в «Qt5.5.0\5.5\Src»
• Теперь запускаем терминал Qt — Qt 5.5 for Desktop (MinGW 4.9.2 32 bit), он находится
  в «Все программы -> Qt5.5.0 -> 5.5 -> MinGW 4.9.2 (32-bit)» или же полным путем «%appdata%\Microsoft\Windows\Start Menu\Programs\Qt 5.5.0\5.5\MinGW 4.9.2 (32-bit)«
• Переходим в директорию с исходниками Qt, вводим команду
• Конфигурируем этап установки, вводя команду, где путь после -prefix, местоположение комплекта сборки
• По завершению конфигурирования, начинаем компиляцию исходников Qt, командой

После компиляции, будет несколько ошибок, не обращаем на них внимание, они никак не скажутся на нашей сборке.
Копируем файлы в указанный нами каталог на этапе конфигурирования, командой

После копирования, так же будет несколько ошибок, не обращаем на них внимание.

Теперь восстанавливаем резервные копии исходников Qt и qmake.conf

Добавляем статичный комплект в Qt Creator

• Запускаем Qt Creator
• Открываем «Инструменты -> Параметры..»
• Далее переходим «Сборка и запуск -> Qt Versions»
• Жмем добавить и выбираем qmake.exe, точнее «X:\Qt\Qt5.5.0_Static\bin\qmake.exe»
• Переходим во вкладку «Комплекты»
• Жмем добавить
• Пишем название нашего комплекта «Qt 5.5.0 Static MinGW 32», в профиле Qt указываем наш статичный профиль, который добавили в Qt Versions, так же указываем версию нашего компилятора и отладчика(MinGW)
• Все, мы добавили статичный комплект в Qt Creator

Примечание: в статический комплект не будут включены библиотеки gcc, что бы они так же собирались в исполняемый файл, надо прописать в .pro/.pri

Спасибо за внимание!

Данная статья не подлежит комментированию, поскольку её автор ещё не является полноправным участником сообщества. Вы сможете связаться с автором только после того, как он получит приглашение от кого-либо из участников сообщества. До этого момента его username будет скрыт псевдонимом.

Qt Documentation

Contents

This page describes the process of configuring and building Qt for Windows. Before building, there are some requirements that are given in more detail in the Qt for Windows — Requirements document.

You can download the Qt 5 sources from the Downloads page. For more information, visit the Getting Started with Qt page.

Step 1: Install the License File (Commercially Licensed Qt Only)

If you use Qt with a commercial license, the Qt tools look for a local license file. If you are using a binary installer or the commercial Qt Creator, your licenses are automatically fetched and stored in your local user profile ( %USERPROFILE%\AppData\Roaming\Qt\qtlicenses.ini file).

If you do not use any binary installer or Qt Creator, you can download the respective license file from your Qt Account Web portal and save it to your user profile as %USERPROFILE%\.qt-license . If you prefer a different location or file name, you need to set the QT_LICENSE_FILE environment variable to the respective file path.

Step 2: Unpack the Archive

Uncompress the files into the directory you want Qt installed; e.g. C:\Qt\%VERSION% .

Note: The install path must not contain any spaces or Windows specific file system characters.

Step 3: Set the Environment Variables

We recommend creating a desktop link that opens a command prompt with the environment set up similar to the Command Prompt menu entries provided by Visual Studio. This is done by creating an application link passing a .cmd file setting up the environment and the command line option /k (remain open) to cmd.exe .

Assuming the file is called qt5vars.cmd and the Qt folder is called Qt-5 and located under C:\Qt :

A desktop link can then be created by specifying the command %SystemRoot%\system32\cmd.exe /E:ON /V:ON /k C:\Qt\qt5vars.cmd as application and C:\Qt\Qt-5 as working directory.

Note: Setups for MinGW are similar; they differ only in that the bin folder of the installation should be added to the path instead of calling the Visual Studio setup script. For MinGW, please make sure that no sh.exe can be found in the path, as it affects mingw32-make .

Settings required by the additional libraries (see Qt for Windows — Requirements) should also go this file below the call to the Windows SDK setup script.

Step 4: Build the Qt Library

The default behavior of configure is to create an in-source build of Qt 5. If you want to install Qt 5 to a separate location, you need to specify the command line option -prefix . Alternatively, the command line option -developer-build creates an in-source build for developer usage.

To configure the Qt library for a debug build for your machine, type the following command in the command prompt:

The Configure Options page contains more information about the configure options.

To build Qt using jom, type:

If you do not have jom installed, type:

If an installation prefix was given, type jom install , nmake install or mingw32-make install .

Note: If you later need to reconfigure and rebuild Qt from the same location, ensure that all traces of the previous configuration are removed by entering the build directory and typing nmake distclean before running configure again.

Parallel Builds

jom is a replacement for nmake which makes use of all CPU cores and thus speeds up building.

Step 5: Build the Qt Documentation

For the Qt reference documentation to be available in Qt Assistant, you must build it separately:

This will build the documentation in the build folder. If you have installed Qt in a separate location, you will also need to install the documentation:

В© 2021 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

Статическая линковка Qt 5.x.x с MinGW32 в Windows (сборка в один exe’шник)

Доброго времени суток, хабравчане!

Я уверен, что все заметили, когда делали деплой своей программы через windeployqt.exe, программа зависит от разных динамических и qt’шных библиотек. Вследствие чего, развертка на других компьютерах становится неудобной. Почему? Приходится держать сам exe’шник в папке с нужными библиотеками. Разумеется, можно умудриться и без статической линковки решить эту проблему. Согласитесь, неудобно, да и каждый раз нужно лишние телодвижения делать. Проще один раз запариться и потом не делать лишних движений. Еще один плюс статической линковки — размер файла. При динамической линковке сам exe’шник весит примерно от 1 МБ до 7-8 МБ, а с окружением до 70 МБ может спокойно дойти, даже если проект небольшой. При статической линковке есть только exe’шник, который весит примерно в 2 раза меньше, чем окружение при динамической линковке.

Для сборки необходимы:

• Qt 5.x.x с включенными компонентами (если Qt уже был установлен, нужные компоненты можно установить с помощью Qt Maintenance Tool):
• Qt — Qt 5.x — MinGW x.x.x 32 bit
• Qt — Qt 5.x — Sources
• Qt — Tools — MinGW
• Perl (Strawberry Perl, к примеру). Я использую strawberry-perl-5.30.2.1-32bit.
  Проверить, что путь к исполняемому файлу Perl прописан в переменной окружения PATH. Этот пункт можно пропустить, но лучше проверить.
• Python 3.8

Путь установки Qt неважен, у меня он установлен на диске D. Убедитесь, что объем доступной памяти вам хватит. Нужно как минимум 30 ГБ свободного места.

1. Переходите в директорию, где папка Src (D:\Qt\5.x.x\Src);
2. Там создайте папку static (D:\Qt\5.х.х\static);
3. Папку Src копируйте в папку static. Получится D:\Qt\5.x.x\static\Src. Дальнейшие действия будут там, в Папке Src;
4. Создайте папку mingwXX_32 (у меня, например, mingw73_32). Получится D:\Qt\5.x.x\static\mingwXX_32;
5. Редактируйте файл qmake.conf, который находится в D:\Qt\5.х.х\static\Src\qtbase\mkspecs\win32-g++.

В самый конец файла, после строки load(qt_config) допишите с новой строки эти команды:

Сохраниите файл qmake.conf;

Откройте (ВНИМАНИЕ! НЕ CMD! НЕ CMD! НЕ CMD!) командную строку MinGW. В поисковике компьютера (на панели задач) пишите mingw.
Командная строка MinGW будет выдана как Qt 5.x.x (MinGW x.x.x 32-bit)

Введите в командную строку MinGW поочередно следующие команды:
set LANG=en

cd /d %QT_INSTALL_PREFIX%\..\Src (именно такая строка без изменений)

Тут стоит обратить внимание на опцию -no-ssl — это значит что Qt будет собран без поддержки SSL.

Если никаких ошибок нету, можно продолжать:

Введите mingw32-make -k -j4
Нереально длительный процесс, можете смело забыть про него на 4 часа ориентировачно, от скорости чтения/записи диска не зависит, а зависит от процессора. Там где -j4 вместо 4 поставьте число ядер вашего процессора.

Введите mingw32-make -k install
В результате получаем статическое окружение в D:\Qt\5.x.x\statiс\mingwXX_32;

Настройка Qt Creator:

• В верхнем меню Инструменты -> Параметры -> Профили Qt
• Добавить -> D:\Qt\5.х.х\static\mingw73_32\bin\qmake.exe -> Применить
• Комплекты -> Добавить
• Название: Qt static x32 (или какое угодно)
• Тип Устройства: Desktop
• Устройство: Локальный ПК
• Корень образа: D:\Qt\5.х.х\static
• Компилятор:
  a) для С: MinGW x.x.x 32-bit for C
  b) для С++: MinGW x.x.x 32-bit for C++
• Профиль Qt: Qt static x32 (название профиля, которое вы указали при добавлении профиля)
• Применить -> Ок

Остается только пересобрать свой проект с новым комплектом.

Дополнительная информация. У меня:

• Qt 5.14.1
• MinGW 7.3.0 32-bit (mingw73_32)
• Python 3.8 x32
• strawberry-perl-5.30.2.1-32bi
• Windows 10 Pro x64

Полет нормальный.

Брал информацию отсюда:

Данная статья не подлежит комментированию, поскольку её автор ещё не является полноправным участником сообщества. Вы сможете связаться с автором только после того, как он получит приглашение от кого-либо из участников сообщества. До этого момента его username будет скрыт псевдонимом.

Qt Documentation

Contents

This page describes the required libraries and environment for Qt for Windows.

Libraries

The following third-party libraries may be used when running Qt 5 applications on Windows.

• OpenSSL Toolkit: Qt can make use of OpenSSL to support Secure Socket Layer (SSL) communication.
• ICU: Qt 5 can make use of the ICU library for enhanced UNICODE and Globalization support (see QTextCodec, QCollator::setNumericMode()).

At compile time, the include and lib folders of the ICU installation must be appended to the INCLUDE and LIB environment variables. At run-time, the ICU DLLs need to be found by copying the DLLs to the application folder or by adding the bin folder of the ICU installation to the PATH environment variable.

ANGLE: This library converts OpenGL ES 2.0 API calls to DirectX 11 or DirectX 9 calls (depending on availability), removing the need to install graphics drivers on the target machines.

Support for Secure Sockets Layer (SSL) communication is provided by the OpenSSL Toolkit, which must be obtained separately. Download the latest version of the toolkit that is supported by Qt.

Qt can be configured to use OpenSSL in three ways:

Qt Network loads OpenSSL libraries (DDLs) when first needed, at runtime. If not found, the application continues to run, but fails to handle SSL communication.

All official Qt binary builds use this configuration.

The OpenSSL libraries are looked up first in the directory of the executable, then in the Windows System directory (usually C:\Windows\system32 ), and finally in all directories listed in the PATH environment variable.

Qt Network links against the OpenSSL libraries. If they cannot be found at load time, the application fails to start.

Qt Network compiles against a static version of the OpenSSL libs, and OpenSSL becomes part of the Qt5Network library.

If you compile Qt yourself, you can configure how Qt uses OpenSSL by setting either the -openssl / -openssl-runtime or -openssl-linked configure flags.

If OpenSSL is not found in the normal compiler include and library directories, you can set either the OPENSSL_PREFIX , or OPENSSL_INCDIR and OPENSSL_LIBDIR configure arguments. If OPENSSL_PREFIX is set, OPENSSL_INCDIR defaults to OPENSSL_PREFIX/include and OPENSSL_LIBDIR to OPENSSL_PREFIX/lib .

The actual libraries to link to can be tweaked by setting the OPENSSL_LIBS , OPENSSL_LIBS_DEBUG , and OPENSSL_LIBS_RELEASE configure arguments.

To load OpenSSL at runtime, set the -openssl-runtime configure argument. Qt will try to find openssl/ssl.h and openssl/opensslv.h in the default include path of the compiler. You can specify an additional include directory by setting OPENSSL_INCDIR .

See Secure Sockets Layer (SSL) Classes for further instructions on Qt with SSL support.

From Qt 5.3 and onwards, configure does not link Qt Core against ICU libraries anymore by default. This reduces the size of a self-contained application package considerably.

Letting Qt Core utilize the ICU libraries however has following advantages:

• Behavior matches other platforms more closely.
• Extended set of text codecs (see QTextCodec).
• QLocale::toUpper(), QLocale::toLower() always use case conversion rules specific to the locale.
• QCollator::setNumericMode() does work consistently on all Windows versions.

To explicitly enable the use of ICU in Qt Core, pass -icu to configure :

Graphics Drivers

For Qt Quick 2 to work, a graphics driver that provides OpenGL 2.1 or higher is required. The default driver from Windows is OpenGL 1.1. Qt includes a version of the ANGLE project which is included from the Windows Qt installers. ANGLE implements the OpenGL ES 2.0 API on top of DirectX 11 or DirectX 9.

ANGLE requires that the DirectX SDK is installed when building Qt. If MSVC is used, the DirectX SDK will be provided by the Windows SDK. In this case, you will need at least Windows SDK 10. For MinGW builds, you have to install the DirectX SDK provided by Microsoft.

ANGLE chooses the render backend depending on availability. DirectX 11 is usually preferable. However, some graphics cards may not fully support it. For these cases, the environment variable QT_ANGLE_PLATFORM (introduced in Qt 5.4) can be used to control the render backend. Possible values are d3d11 , d3d9 and warp .

To use a custom version of ANGLE, set the ANGLE_DIR environment variable to point to the ANGLE source tree before building Qt.

If you installed additional OpenGL drivers from your hardware vendor, then you may want to consider using this version of OpenGL instead of ANGLE. To use OpenGL, pass the command line options -opengl desktop to the configure script.

To use an OpenGL ES 2.0 emulator instead of ANGLE, use the configure options: -opengl es2 -no-angle .

Dynamically Loading Graphics Drivers

In addition to the build time configuration, Qt supports choosing and loading the OpenGL implementation at runtime. To use this mode, pass -opengl dynamic to the configure script.

Note: As of Qt 5.5 this is the configuration used by the official, pre-built binary packages of Qt. It is strongly recommended to use it also in custom builds, especially for Qt binaries that are deployed alongside applications.

Note: Combining -opengl dynamic with -static is also possible, but be aware that ANGLE will not be statically linked into the applications in this case, it will still be built as a shared library.

This configuration is the most flexible because no dependencies or assumptions are hardcoded about the OpenGL implementation during build time. It allows robust application deployment. When a given environment fails to provide a proper OpenGL 2.0 implementation, it will fall back automatically to ANGLE. This fallback will be completely transparent to the application, and will allow Qt Quick or other OpenGL code to function by translating to Direct3D. Such a fallback could, for example, take place on a Windows 7 PC with no additional graphics drivers installed. On other machines, where there is sufficient OpenGL support, the normal desktop OpenGL drivers will be used. Additionally, pure software-based OpenGL implementations may be available as additional fallbacks in the future, allowing running Qt Quick applications without a GPU.

When configured with -opengl dynamic , neither Qt nor the applications built using qmake will link to the opengl32 (standard desktop OpenGL) or QtANGLE libraries. Instead, the appropriate library is chosen at runtime. By default, Qt will determine whether the system’s opengl32.dll provides OpenGL 2 functions. If these are present, opengl32.dll is used, otherwise the ANGLE libraries (libEGL.dll and libGLESv2.dll) will be used. In case the ANGLE libraries are missing or initialization fails for some reason, an additional fallback is attempted by trying to load opengl32sw.dll . See below for details.

The loading mechanism can be configured through the QT_OPENGL environment variable and the following application attributes:

• Qt::AA_UseDesktopOpenGL Equivalent to setting QT_OPENGL to desktop .
• Qt::AA_UseOpenGLES Equivalent to setting QT_OPENGL to angle .
• Qt::AA_UseSoftwareOpenGL Equivalent to setting QT_OPENGL to software .

When a certain configuration is requested explicitly, no checks are done at application startup, that is, the system-provided opengl32.dll will not be examined.

The dynamic loading has a significant impact on applications that contain native OpenGL calls: they may fail to link since qmake no longer automatically adds opengl32.lib or libGLESv2.lib. Instead, applications are expected to use the OpenGL functions via the QOpenGLFunctions class. Thus the direct dependency on the OpenGL library is removed and all calls will be routed during runtime to the implementation chosen by Qt.

Applications that require a certain OpenGL implementation (for example, desktop OpenGL due to relying on features provided by OpenGL 3.0 or higher) should set the application attributes Qt::AA_UseOpenGLES or Qt::AA_UseDesktopOpenGL before instantiating QGuiApplication or QApplication. When these attributes are set, no other OpenGL implementations are considered. Additionally, if they wish to, such applications are free to make direct OpenGL function calls by adding opengl32.lib to their .pro project files: LIBS += opengl32.lib (Visual Studio) or LIBS += -lopengl32 (MinGW). The result is, from the application’s perspective, equivalent to the -opengl desktop build configuration of Qt.

Qt::AA_UseSoftwareOpenGL is special in the sense that it will try to load an OpenGL implementation with a non-standard name. The default name is opengl32sw.dll . This allows shipping a software-only OpenGL implementation, for example a build of Mesa with llvmpipe, under this name. If necessary, the filename can be overridden by setting the QT_OPENGL_DLL environment variable.

It is possible to provide a JSON-format configuration file specifying which OpenGL implementation to use depending on the graphics card and driver version. The location is given by the environment variable QT_OPENGL_BUGLIST . Relative paths are resolved using QLibraryInfo::SettingsPath or QStandardPaths::ConfigLocation . The file utilizes the format of the driver bug list used in The Chromium Projects. It consists of a list of entries each of which specifies a set of conditions and a list of feature keywords. Typically, device id and vendor id are used to match a specific graphics card. They can be found in the output of the qtdiag or dxdiag tool.

The following feature keywords are relevant for choosing the OpenGL implementation:

• disable_desktopgl — Disables OpenGL. This ensures that Qt does not attempt to use regular OpenGL (opengl32.dll), and that it starts with ANGLE right away. This is useful to prevent bad OpenGL drivers from crashing the application.
• disable_angle — Disables ANGLE. Ensures that Qt does not attempt to use ANGLE (and so Direct3D).
• disable_d3d11 — Disables the D3D11 rasterizer in ANGLE. Instead, the next D3D rendering option is tried first. The default order is: D3D11, D3D9, WARP, reference implementation.
• disable_d3d9 — Disables the D3D9 rasterizer in ANGLE
• disable_rotation — Forces the application to run in landscape orientation always. It applies to OpengGL only and has no effect when using ANGLE or Software OpenGL implementations. This is intended for drivers that have issues with rotation. This feature keyword was introduced in Qt 5.6.
• disable_program_cache — Disable storing shader program binaries on disk. This feature keyword was introduced in Qt 5.12.

A sample file looks like:

When QT_OPENGL_BUGLIST is not specified, a built-in list will be used. This typically includes some older, less-capable graphics cards with disable_desktopgl set, in order to prevent Qt from using their unstable desktop OpenGL implementations and instead fall back to ANGLE right away.

In practice the most common combinations are expected to be the following:

• disable_desktopgl — In case the system provides OpenGL 2.0 or newer, but the driver is known to be unstable and prone to crash.
• disable_desktopgl , disable_angle — When no accelerated path is desired. This ensures that the only option Qt tries is the sofware rasterizer (opengl32sw.dll). Can be useful in virtual machines and applications that are deployed on a wide range of old systems.
• disable_d3d11 , disable_d3d9 — When the accelerated D3D options are known to be unstable and WARP is desired (when available). Can be useful in virtual machines.

The supported keys for matching a given card or driver are the following. Note that some of these are specific to Qt.

• os.type — Operating system: win , linux , macosx , android
• os.version — Kernel version
• os.release — Specifies a list of operating system releases on Windows: xp , vista , 7 , 8 , 8.1 , 10 .
• vendor_id — Vendor from the adapter identifier
• device_id — List of PCI device IDs.
• driver_version — Driver version from the adapter identifier
• driver_description — Matches when the value is a substring of the driver description from the adapter identifier
• gl_vendor — Matches when the value is a substring of the GL_VENDOR string

To disable all blacklisting, set the environment variable QT_NO_OPENGL_BUGLIST to any value. This will skip reading any configuration files, and instead will assume that nothing is disabled, regardless of the driver or OS.

Note: While not typically needed, QT_NO_OPENGL_BUGLIST can become relevant in certain virtualized environments, with multiple, possibly virtual, graphics adapters present. If the logs from categories like qt.qpa.gl indicate that the detection of the driver and display adapter leads to incorrectly disabling OpenGL, it is then recommended to set this environment variable in order to enable the application to run normally. This environment variable was introduced in Qt 5.15.

Building from Source

These tools are not needed to run Qt 5 applications, but they are required for building Qt 5 from source.

• ActivePerl — Install a recent version of ActivePerl (download page) and add the installation location to your PATH .
• Python — Install Python from the here and add the installation location to your PATH .

Note: Please make sure that the perl executable from ActivePerl is found in the path before the perl executable provided by msysgit, since the latter is outdated.

ANGLE depends on these extra tools from the GnuWin32 and Win flex-bison projects, which are provided for your convenience in the gnuwin32/bin folder:

The gnuwin32/bin folder should be added to the PATH variable.

Note: If you are building qtbase outside of qt5.git, you will need to download win_bison and win_flex from the link above and rename them to bison and flex.

For instructions for building the Qt 5 source, read the Qt for Windows — Building from Source page.

Compilers

Visual Studio

Qt can be built with Visual Studio 2015 (Update 2), Visual Studio 2017, Visual Studio 2019 and Build Tools for Visual Studio 2017 and 2019 (see also Supported Platforms).

Intel C++ Compiler (Windows, Altix)

Qt has been tested successfully with:

• Windows — Intel(R) C++ Compiler for 32-bit applications, Version 9.1.040.
• Altix — Intel(R) C++ Itanium(R) Compiler for Itanium(R)-based applications Version 8.1 Build 20050406 Package ID: l_cc_pc_8.1.030

GCC (MinGW-builds)

The minimum version of MinGW-builds supported is GCC 5.1.0 (64bit, 32bit), available from its download page.

For more information about the MinGW builds, visit the Reference Configuration section of the supported platforms page.

Clang(clang-cl)

Qt has been tested successfully with Clang 3.8(llvm svn rev. 256453 and clang svn rev. 256453). Visual Studio 2015 Update 1 was used to build clang. Mkspec is using the clang-cl tool to build Qt. Clang 3.8 does not support precompiled headers.

Building Qt WebEngine

Qt WebEngine has additional build requirements which are listed in the Qt WebEngine Platform Notes.

QDoc Dependencies

Since version 5.11, QDoc uses Clang to parse C++ code. If you wish to build QDoc manually, refer to Installing Clang for QDoc for specific build requirements.

В© 2021 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.