qmake

qmake turns project files into Makefiles to manage builds for applications, libraries, and other components. Its .pro files can describe source files, configuration, libraries, and include paths. qmake supplies build rules for Qt’s moc and uic tools, and offers templates for applications, libraries, and plugins. Project files can reference third-party libraries, while pkg-config support is available for libraries such as D-Bus and ogg. qmake can also generate Microsoft Visual Studio project files and, on macOS, Xcode project files. The platform notes describe iOS support for universal binaries, frameworks, and bundles. In Qt 6, qmake remains supported for building Qt applications, but it cannot compile custom Qt plugins or libraries that rely on Qt 5 build-system internals. Qt warns that a project being built is treated as trusted input, so building an untrusted project can execute code on the build machine. qmake is free through the Qt Community Edition under LGPL or GPL terms; those terms require source code to be open to copy, modify, and distribute, and some Qt capabilities have limited access.

qmake remains an option for Qt application builds and supports several project-generation workflows. Review the Qt 6 limitation and treat project inputs as trusted before building.

qmake suits developers building Qt applications and other components who want project-file-based Makefile generation. Its Qt 6 limitation matters to developers building custom plugins or libraries that depend on Qt 5 internals.

qmake is a build tool for Qt projects, turning project files into Makefiles. It suits developers who want Qt-specific build rules or project files for Visual Studio and Xcode. Its value is clearest in Qt workflows; Qt 6 imposes a significant limit on custom plugins and libraries.

Overview

Build settings live in .pro files, where teams can specify source files, configuration, libraries, and include paths. qmake expands those inputs into Makefiles, giving projects a defined build description without requiring developers to write those Makefiles directly. Its Qt-specific integration makes it a focused choice, not a general-purpose answer for every build process.

Qt Group is headquartered in Espoo, Finland, and says the first public Qt Framework version arrived in 1995. That history places qmake within a mature Qt ecosystem, but the tool’s suitability still depends on the project’s Qt version and build requirements.

Key features

• Qt build rules: qmake automatically includes rules for Qt’s moc and uic tools. For Qt projects, that means those tool steps are part of the build workflow rather than requiring separate build-rule setup.
• Templates for common project types: Templates support applications, libraries, and plugins. The plugin template should not be mistaken for unrestricted Qt 6 support: qmake cannot compile custom Qt plugins or libraries that depend on Qt 5 build-system internals.
• Dependency configuration: Project files can identify third-party libraries and include paths. For supported libraries such as D-Bus and ogg, qmake can also use pkg-config, making it a reasonable fit when those dependencies are part of the project.
• IDE project generation: qmake can generate Microsoft Visual Studio project files and, on macOS, Xcode project files. This helps teams that want to use those IDEs alongside the qmake project description.
• iOS build options: Its iOS features include creating universal binaries, frameworks, and bundles. That gives iOS Qt projects several target packaging options within the tool.

Pricing

qmake is free. The Qt Community Edition costs nothing and is available for open-source use under LGPL or GPL terms. Those terms require source code to be open to copy, modify, and distribute, and the edition has limited access to some Qt capabilities. It suits qualifying open-source projects; teams needing capabilities outside that edition or terms should consider Qt’s commercial licensing instead.

Platforms

qmake supports iOS, Linux, macOS, and Windows. Its project-generation options are platform-specific: Visual Studio project files are supported, while Xcode project generation is for macOS. The platform coverage is useful for Qt projects spanning these systems, but should not be read as a claim that every feature behaves identically on each one.

Who it's for

qmake is best for developers building Qt applications who want `.pro` files to define project settings and automatically use Qt’s moc and uic rules. It also fits teams that need third-party dependency configuration, supported pkg-config integration, or project files for Visual Studio or Xcode. It is a weaker fit for Qt 6 developers building custom plugins or libraries tied to Qt 5 build-system internals, and for projects that do not benefit from Qt-specific build integration.

Pros and cons

Pros

• Qt tools are integrated into the build rules: Automatic moc and uic rules are useful for projects that depend on those Qt tools.
• Project descriptions cover several needs: `.pro` files can define sources, settings, libraries, and include paths, while templates cover applications, libraries, and plugins.
• Multiple development workflows: Visual Studio and macOS Xcode project generation, plus iOS packaging features, give Qt teams options beyond direct Makefile generation.
• No software charge: qmake is free, though Qt Community Edition use carries LGPL or GPL terms and capability limits.

Cons

• Qt 6 has a hard boundary: Custom plugins and libraries that rely on Qt 5 build-system internals cannot be compiled with qmake, which rules it out for those projects.
• Community licensing is conditional: The open-source edition requires source code to remain open to copying, modification, and distribution, and does not include every Qt capability.
• Build inputs require trust: qmake treats processed projects as trusted input, so building an untrusted project can execute code on the build machine. Teams should only build project inputs they trust.

Alternatives

Choose fastlane instead if you want a free, MIT-licensed open-source option with Android and iOS among its supported platforms. Qbs is another free option, with commercial, LGPL version 3, and GPL version 2 licensing; consider it if those licensing choices better fit your project.

Xmake is a free alternative with no free trial and support for Android, iOS, Linux, macOS, and Windows. Bazel, identified by Google as its build tool, is free and open-source for building and testing, and supports Linux, macOS, and Windows.

Buildroot is a free, open-source embedded Linux build tool for Linux and self-hosted use, with commercial LTS sponsorship tiers available by inquiry. FASTBuild is free open-source software whose license permits commercial use and redistribution, and it supports Linux, macOS, and Windows.

Nx may suit teams looking for a freemium option: its free Hobby plan is billed free forever and includes 50,000 credits resetting monthly, five contributors, 10 concurrent CI connections, and community support. Open Build Service is free GPL-licensed software with a reference server for open-source developers and an option to install it on your own infrastructure.

For more options, browse Build Automation Software.

Verdict

Choose qmake if you are building Qt applications and want Qt-aware build rules, `.pro` project configuration, and supported IDE project generation without paying for the tool. Look elsewhere if your Qt 6 work requires custom plugins or libraries that depend on Qt 5 build-system internals, or if the Qt Community Edition’s open-source terms and capability limits do not fit.

Qt describes application security as a shared responsibility among developers, Qt Group and Qt Project, and operators or device manufacturers. It directs reports about open-source Qt vulnerabilities to [email protected] and says it does not currently have a bug bounty program.