5 Essential Qt Licensing Tips: How to Legally Distribute and Sell Your Applications

When developing an application with Qt, understanding the licensing options is crucial, especially if you plan to distribute or sell your software. In this article, we’ll cover the different Qt licenses, dynamic vs. static linking, and how your CLion and CMake setup impacts licensing compliance. By the end, you’ll know how to stay legally compliant and confidently distribute or sell your app.

Qt Licensing Compliance Overview

Qt offers two primary licensing models:

1. Commercial License
2. Open-Source Licenses (GPL and LGPL)

1. Commercial License

The Qt Commercial License allows you to create proprietary applications without sharing your source code. This license is a paid option and is ideal for developers who want to:

• Keep their code private.
• Avoid the obligations of open-source licenses.

If you use the Commercial License, you can distribute and sell your app freely, whether it’s free or paid, without worrying about LGPL or GPL requirements.

2. Open-Source Licenses Qt LGPL vs GPL

Qt’s open-source licensing comes with two main options:

GNU General Public License (GPL)

• Requirements: If you use the GPL version of Qt, your entire application must also be licensed under the GPL.
• Implication: You must release your source code and allow others to modify and redistribute it under the GPL.
• When to Use: If you are creating an open-source project and are comfortable with your code being open-source.

GNU Lesser General Public License (LGPL)

• Requirements: If you use the LGPL version of Qt, you can keep your application’s source code private as long as you dynamically link to the Qt libraries.
• Key Rules:

1. Dynamic Linking: Your app must load the Qt libraries at runtime (e.g., .dll files on Windows).
2. Library Replacement: Users must be able to replace the Qt libraries with their own versions.
3. License Notice: Include a copy of the LGPL license and a notice in your app acknowledging the use of LGPL-licensed libraries.

• When to Use: If you want to create a proprietary app without purchasing a commercial license, as long as you dynamically link.

Dynamic Linking vs. Static Linking

The way you link to Qt libraries affects LGPL compliance:

Dynamic Linking

• What It Is: Your app loads the Qt libraries at runtime using shared library files (.dll on Windows, .so on Linux, .dylib on macOS).
• Compliance: Meets LGPL requirements because users can replace the libraries.
• Pros:
• Smaller executable size.
• Easy to update libraries independently.
• Cons:
• You need to distribute the .dll files with your app.

Example in CMake (Dynamic Linking):

find_package(Qt6 COMPONENTS Core Gui Widgets REQUIRED)
target_link_libraries(RambodCraft Qt::Core Qt::Gui Qt::Widgets)

Static Linking

• What It Is: The Qt libraries are compiled directly into your executable.
• Compliance: Does not comply with LGPL unless you release your application’s source code and allow relinking.
• Pros:
• No need to distribute separate library files.
• Cons:
• Larger executable size.
• Must comply with GPL or purchase a commercial license.

Note: Static linking is generally avoided when using the LGPL version of Qt unless you’re ready to open-source your app or purchase a commercial license.

How Your CLion and CMake Setup Affects Licensing

Let’s analyze a typical project setup with CLion and CMake:

Example Project Structure

RambodCraft/
├── cmake-build-debug/
│   ├── Qt6Core.dll
│   ├── Qt6Gui.dll
│   ├── Qt6Widgets.dll
│   └── RambodCraft.exe
├── LoginWindow/
│   ├── loginwindow.cpp
│   ├── loginwindow.h
│   └── loginwindow.ui
├── MainWindow/
│   ├── mainwindow.cpp
│   ├── mainwindow.h
│   └── mainwindow.ui
├── CMakeLists.txt
└── main.cpp

CMake Configuration

In your CMakeLists.txt:

find_package(Qt6 COMPONENTS Core Gui Widgets REQUIRED)
target_link_libraries(RambodCraft Qt::Core Qt::Gui Qt::Widgets)

This setup dynamically links to the Qt libraries, as evidenced by the .dll files in the cmake-build-debug folder. This means:

1. You are LGPL-compliant as long as you distribute the required notices and licenses.
2. You can sell your app without releasing your source code.

Steps to Ensure LGPL Compliance

To distribute or sell your dynamically linked application under the LGPL:

1. Dynamically Link to Qt libraries (e.g., .dll files).
2. Include the LGPL License:

• Distribute a copy of the LGPL license (e.g., COPYING.LGPL).

1. Provide Attribution:

• Add a notice in your documentation or “About” section stating that your app uses LGPL-licensed Qt libraries.

1. Allow Library Replacement:

• Ensure the .dll files are accessible so users can replace them with their own versions.

1. Reference Qt Source Code:

• Provide a link to the official Qt source code: https://download.qt.io/

Example Attribution:

This application uses the Qt framework, licensed under the GNU Lesser General Public License (LGPL).
For more information, visit https://www.qt.io/licensing.

Selling Qt Applications

You can sell your application without releasing the source code if:

• You dynamically link to LGPL-licensed Qt libraries.
• You follow the LGPL compliance steps listed above.

If you prefer not to handle LGPL requirements, consider purchasing a Qt Commercial License.

Conclusion

By dynamically linking to Qt libraries and following LGPL guidelines, you can create, distribute, and sell proprietary applications without releasing your source code. Tools like CLion and CMake make it easy to set up dynamic linking, ensuring compliance with LGPL requirements.

For more details, refer to the official Qt licensing documentation:

• Qt Licensing Overview: https://www.qt.io/licensing
• LGPL License Text: https://www.gnu.org/licenses/lgpl-3.0.html

Stay informed and happy coding!

This article is part of my learning journey at rambod.net. Feel free to share your thoughts and experiences!