How to use MinGW-64 with Qt Creator

Question

I am aware that there are many post about this, but I honestly didn't understood any of it.

So, how do I install a kit for my Qt Creator (open source 5.7)?

• I already downloaded and installed MSYS2.... don't know what to do with it.
• I already downloaded and installed Qt64 - NG.... no clue what to do next.

I just want to be able to develop in Qt and chose betwen MinGW 32 and MinGW 64.

Thanks in advance!

---

EDIT: I also checked the wiki page. Most of the commands didn't worked. And I was told that it is outdated.

Answer 1

I know that your question is how do you install a kit for your Qt Creator, but first I think it's needed an introduction (Sorry for your eyes, English it's not my native language)

Introduction

The intention is to use the GCC compiler under Windows, what mean we need MinGW (Minimalist GNU for Windows).

MinGW only works for 32 bits, so we need the 64 bits forks, what means to use the MinGW-w64 or TDM-GCC flavors.

• MinGW , GCC compiler for 32bits applications.
• MinGW-w64 , GCC compiler for 32 and 64 bits applications.
• TDM-GCC , GCC compiler for 32 and 64 bits applications.

With that we can create our applications/programs in Windows. In addition, we have other two different tools:

• Qt Framework library, for create GUI's/Interfaces with multi-platform compatibility.
• Qt Creator , an C/C++ editor, with additional editing tools for the Qt Framework.

About the binary compatibility chain

When we make an application, we've to follow the chain of libraries compiled with the same compiler version, the same way we've to follow the application binary interface (32 or 64 bits) for those libraries.

This means, if we want to compile an application for 32 and 64 bits with MinGW-w64 5.3, plus the Qt 5.7 Framework, we need:

• MinGW-w64 5.3 (with flags 32 bits in the config) and the Qt 5.7 Framwork 32 bits build compiled under MinGW-w64 (MinGW-w64 version 5.3 or lower as long as they maintain binary code compatibility with our compiler).
• MinGW-w64 5.3 (with flags 64 bits in the config) and the Qt 5.7 Framwork 64 bits build compiled under MinGW-w64 (MinGW-w64 version 5.3 or lower as long as they maintain binary code compatibility with our compiler).

Now come the weird thing. At Qt official webpage it's only available the 32bits builds for MinGW... I don't know why...

Here is when come the Qt64-NG project, a place where get the Qt Framework 64bits binary packages for MinGW-w64. Unfortunately the project is closed, so only are available until the Qt 5.5 Framework version.

I don't know other place where to get newer 64bits Qt binary packages for MinGW-w64 (Maybe the ones at MSYS2 project? I didn't tried yet). So, if one need it, at this moment must be compiled by oneself (This is for answer your opensource 5.7 comment).

Install and configuration

Now your question. How to install a kit for your Qt Creator. I'm going to answer for 64bit binaries because it's what I use (and latter you just need to do the same thing for 32bits)

For use Qt Creator with MinGW-w64, one just need:

• Download Qt Creator and install it. My advice is to download the 4.1 (or upper version) snapshots if one is going to use CMake projects.

• Download MinGW-w64 (posix-seh , or your choice flavor) + decompress in one folder.

That's all, with this we can create 32 and 64 bits applications.

By other way, in addition to the above steps, if one want to create applications using the Qt Framework library (a GUI/Interface for our applications), it's needed the binary package, this case 64 bit (The 32bit binary package is available at the Qt official page)

• Download Qt64-NG (posix-seh , or your above choose flavor) + decompress in one folder.
  After that it's needed to execute the qtbinpatcher.exe included in that directory, just a double click.
  Note: If you change this directory to other path, execute again qtbinpatcher.

Here is where end the installation process. In my case, I have all under the same folder. Example:

D:\Programacion\mingw64_5.3.0rev0\ D:\Programacion\qt64-ng\qt-5.5.0-x64-mingw510r0-seh\ 

Now you just need to configure QtCreator, in this case:

Tools > Options > C++ , Compilers, Add > MinGW

• In name put the compiler version, MinGW-5.3 x64
  It's the name that will be shown in Kits
• In Compiler path browse for the C++ compiler path, in this case D:\Programacion\mingw64_5.3.0rev0\bin\g++.exe
  
  Take note in ABI it's selected to use 64 bits flags in the compiler. That's why we put in name x64. For 32 bits, just duplicate and change the selection.

Tools > Options > C++ , Debuggers, Add

• In Path browse to the debugger path, in this case D:\Programacion\mingw64_5.3.0rev0\bin\gdb.exe
  
• In name put the name showed at version, GDB 7.10.1 in this case.
  It's the name that will be shown in Kits

And, if one want to create 64bits programs using Qt Framework, in addition to the above:

Tools > Options > C++ , Qt versions, Add, and select the qmake.exe placed at the qt64-ng bin directory.

• In this case is, D:\Programacion\qt64-ng\qt-5.5.0-x64-mingw510r0-seh\bin\qmake.exe
  
• In name put Qt %{Qt:Version} (qt-5.5.0-x64-mingw510r0-seh)
  It's the name that will be shown in Kits tab

Now you just need to specify the Kit:

Tools > Options > C++ , Kits, Add

• In name MinGW-5.3 x64 (Qt-5.5)
• In compiler select MinGW-5.3 x64
• In debugger select GDB 7.10.1
• In Qt Version select Qt 5.5.0 (qt-5.5.0-x64-mingw510r0-seh)

And in CMake goes the CMake path if one is going to use it (I use it with Ninja ).

Note: For install Ninja just copy ninja.exe to the mingw-w64\bin directory, and at the Kit, in Cmake generator push change to generator->ninja , and Extra generator->CodeBlocks. Ninja launch several make commands at same time, what decreases compilation times.

Long text for 1 minute of configuration. The Kit is what we select for compile the project, and one can have as many Kits as one wish (CompilerA x32 + Qt5.x , CompilerB x64 + Qt5.x , CompilerX x64 + Qt4.8, etc, etc).

Now, before to finish, an important thing. After we create a project (and the project it's open), at the Projects selector (Ctrl+5) we've to take care of the Build Environment variables.

Those are the variables that are going to be added at the command who launch our Runs/Builds for testing and debug.

In PATH it's needed to put the paths to MinGW-w64 and to Qt64-NG. And under my humble opinion, I recommend to put it in that order because of dll's. Following our example:

PATH D:\Programacion\mingw64_5.3.0rev0\bin;D:\Programacion\qt64-ng\qt-5.5.0-x64-mingw510r0-seh\bin;the_other_paths 

At QtCreator snapshots branch I don't need to check it, it's done automatically

Most of the C/C++ editors works that way. To install editor, specify compiler&debugger path, and specify Build Environment variables for launch from the editor (overriding those environment variable that we've in Windows).

Note: I recommend to compile Qt Creator with 64 bits, due as happen with the Framework, for Windows it's only available in 32 bit at the official Qt website

Alternative way

By other side, we have:

• MSYS2 , a Linux like tools environment.

There is all the same, just we download/install the packages with the pacman command, and are available the 32 and 64 bit versions. Those applications need to be launched from MSYS2 shell. It's not a binary compatibility thing but a paths matter.

The libraries available at MSYS2 project can be used in the first tool chain I described (due are build under MinGW-w64 also).

EDIT: Corrected namings, the last explanation, and added Ninja's url and installation note.

Answer 2

You should decide if you are going to use the MSYS2 ecosystem or not. If you want to use MSYS2, you should uninstall the Qt software that you downloaded separately to avoid confusion. For the rest of this answer, I'll assume you are using MSYS2.

You can install these MSYS2 packages using pacman:

• mingw-w64-i686-qt
• mingw-w64-i686-qt-creator
• mingw-w64-x86_64-qt
• mingw-w64-x86_64-qt-creator

Then open up a MinGW-w64 32-bit or 64-bit shell using the appropriate shortcut in your Start Menu, and run "qtcreator" at the command line.

You can also use other build systems to build your software. I have used CMake successfully for building Qt applications in MSYS2, instead of Qt Creator.