|  | Home · All Classes · Main Classes · Grouped Classes · Modules · Functions |

[Previous: Deploying Qt Applications]

# Deploying an Application on Qt/Windows

This documentation will describe how to determine which files you should include in your distribution, and how to make sure that the application will find them at run-time. We will demonstrate the procedures in terms of deploying the Plug & Paint application that is provided in Qt's examples directory.

Contents:

- Static Linking

- Building Qt Statically
- Linking the Application to the Static Version of Qt

- Shared Libraries

- Building Qt as a Shared Library
- Linking the Application to Qt as a Shared Library
- Creating the Application Package

- Application Dependencies

- Additional Libraries
- Qt Plugins

## Static Linking

If you want to keep things simple by only having a few files to deploy, i.e. a stand-alone executable with the associated compiler specific `DLL`s, then you must build everything statically.

### Building Qt Statically

Before we can build our application we must make sure that Qt is built statically. To do this, go to a command prompt and type the following:

        cd C:\path\to\Qt
        configure -static <any other options you need>

Remember to specify any other options you need, such as data base drivers, as arguments to `configure`. Once `configure` has finished, type the following:

        nmake sub-src

This will build Qt statically. Note that we have used `nmake` in all the examples, but if you use MinGW you must use the `mingw32-make` instead.

### Linking the Application to the Static Version of Qt

Once Qt has finished building we can build the Plug & Paint application. First we must go into the directory that contains the application:

        cd examples\tools\plugandpaint

We must then run `qmake` to create a new makefile for the application, and do a clean build to create the statically linked executable:

        nmake clean
        qmake -config release
        nmake

You probably want to link against the release libraries, and you can specify this when invoking `qmake`. Now, provided that everything compiled and linked without any errors, we should have a `plugandpaint.exe` file that is ready for deployment. One easy way to check that the application really can be run stand-alone is to copy it to a machine that doesn't have Qt or any Qt applications installed, and run it on that machine.

Remember that if your application depends on compiler specific libraries, these must still be redistributed along with your application. You can check which libraries your application is linking against by using the `depends` tool. For more information, see the Application Dependencies section.

The Plug & Paint example consists of several components: The application itself (Plug & Paint), and the Basic Tools and Extra Filters plugins. Since we cannot deploy plugins using the static linking approach, the application we have prepared is incomplete. It will run, but the functionality will be disabled due to the missing plugins. To deploy plugin-based applications we should use the shared library approach.

## Shared Libraries

We have two challenges when deploying the Plug & Paint application using the shared libraries approach: The Qt runtime has to be correctly redistributed along with the application executable, and the plugins have to be installed in the correct location on the target system so that the application can find them.

### Building Qt as a Shared Library

We assume that you already have installed Qt as a shared library, which is the default when installing Qt, in the `C:\path\to\Qt` directory. For more information on how to build Qt, see the Installation documentation.

### Linking the Application to Qt as a Shared Library

After ensuring that Qt is built as a shared library, we can build the Plug & Paint application. First, we must go into the directory that contains the application:

        cd examples\tools\plugandpaint

Now run `qmake` to create a new makefile for the application, and do a clean build to create the dynamically linked executable:

        nmake clean
        qmake -config release
        nmake

This builds the core application, the following will build the plugins:

        cd ..\plugandpaintplugins
        nmake clean
        qmake -config release
        nmake

If everything compiled and linked without any errors, we will get a `plugandpaint.exe` executable and the `pnp_basictools.dll` and `pnp_extrafilters.dll` plugin files.

### Creating the Application Package

To deploy the application, we must make sure that we copy the relevant Qt `DLL` (corresponding to the Qt modules used in the application) as well as the executable to the same directory in the `release` subdirectory.

Remember that if your application depends on compiler specific libraries, these must be redistributed along with your application. You can check which libraries your application is linking against by using the `depends` tool. For more information, see the Application Dependencies section.

We'll cover the plugins shortly, but first we'll check that the application will work in a deployed environment: Either copy the executable and the Qt `DLL`s to a machine that doesn't have Qt or any Qt applications installed, or if you want to test on the build machine, ensure that the machine doesn't have Qt in its environment.

If the application starts without any problems, then we have successfully made a dynamically linked version of the Plug & Paint application. But the application's functionality will still be missing since we have not yet deployed the associated plugins.

Plugins work differently to normal `DLL`s, so we can't just copy them into the same directory as our application's executable as we did with the Qt `DLL`s. When looking for plugins, the application searches in a `plugins` subdirectory inside the directory of the application executable.

So to make the plugins available to our application, we have to create the `plugins` subdirectory and copy over the relevant `DLL`s:

        plugins\pnp_basictools.dll
        plugins\pnp_extrafilters.dll

An archive distributing all the Qt `DLL`s and application specific plugins required to run the Plug & Paint application, would have to include the following files:

Component | File Name
--- | ---
The executable | `plugandpaint.exe`
The Basic Tools plugin | `plugins\pnp_basictools.dll`
The ExtraFilters plugin | `plugins\pnp_extrafilters.dll`
The Qt Core module | `qtcore4.dll`
The Qt GUI module | `qtgui4.dll`

In addition, the archive must contain the following compiler specific libraries depending on your version of Visual Studio:

| VC++ 6.0 | VC++ 7.1 (2003)
--- | --- | ---
The C run-time | `msvcrt.dll` | `msvcr71.dll`
The C++ run-time | `msvcp60.dll` | `msvcp71.dll`

To verify that the application now can be successfully deployed, you can extract this archive on a machine without Qt and without any compiler installed, and try to run it.

An alternative to putting the plugins in the plugins subdirectory is to add a custom search path when you start your application using QApplication::addLibraryPath() or QApplication::setLibraryPaths().

        qApp->addLibraryPath("C:\some\other\path");

One benefit of using plugins is that they can easily be made available to a whole family of applications.

It's often most convenient to add the path in the application's `main()` function, right after the QApplication object is created. Once the path is added, the application will search it for plugins, in addition to looking in the `plugins` subdirectory in the application's own directory. Any number of additional paths can be added.

## Application Dependencies

### Additional Libraries

Depending on configuration, compiler specific libraries must be redistributed along with your application. You can check which libraries your application is linking against by using the `depends` tool. To use the `depends` tool, all you need to do is to run it like this:

        depends <application executable>

This will provide a list of the libraries that your application depends on and other information.

When looking at the release build of the Plug & Paint executable (`plugandpaint.exe`) with the `depends` tool, the tool lists the following immediate dependencies to non-system libraries:

Qt | VC++ 6.0 | VC++ 7.1 (2003) | MinGW
--- | --- | --- | ---
QTCORE4.DLL - The QtCore runtime QTGUI4.DLL - The QtGui runtime | MSVCRT.DLL - The C runtime MSVCP60.DLL - The C++ runtime (only when STL is installed) | MSVCR71.DLL - The C runtime MSVCP71.DLL - The C++ runtime (only when STL is installed) | MINGWM10.DLL - The MinGW run-time

When looking at the plugin `DLL`s the exact same dependencies are listed.

### Qt Plugins

Your application may also depend on one or more Qt plugins, such as the JPEG image format plugin or a SQL driver plugin. Be sure to distribute any Qt plugins that you need with your application.

The search path for Qt plugins (as well as a few other paths) is hard-coded into the QtCore library. By default, the first plugin search path will be hard-coded as `C:\path\to\Qt\plugins`. Using pre-determined paths has certain disadvantages. For example, they may not exist on the target machine. For that reason you need to examine various alternatives to make sure that the Qt plugins are found:

- Using QApplication::addLibraryPath() or QApplication::setLibraryPaths().
- Using a third party installation utility to change the hard-coded paths in the QtCore library.
- Using `qt.conf`. This is the recommended approach since it provides the most flexibility.

[Previous: Deploying Qt Applications]