Hubbry Logo
search
logo
Qt (software) avatar
Qt (software)
Qt (software)
current hub
2318763

Qt (software)

logo
Community Hub0 Subscribers
Read side by side
Qt (software)
View on Wikipedia
from Wikipedia

Qt
Original authorsHaavard Nord and Eirik Chambe-Eng[1]
Developers
Initial release20 May 1995; 30 years ago (1995-05-20)[1]
Stable release
6.10[2] Edit this on Wikidata / 7 October 2025; 15 days ago (7 October 2025)
Repository
Written inC++ (C++17)
Operating systemAndroid, Genode / Sculpt, Haiku, iOS, Linux (embedded, Wayland, X11), macOS, Microsoft Windows, WebAssembly, ...[3]
PlatformCross-platform
TypeCross-platform software and Software development tools
License
Websitewww.qt.io

Qt (/ˈkjuːt/ pronounced "cute"[7][8]) is a cross-platform application development framework for creating graphical user interfaces as well as cross-platform applications that run on various software and hardware platforms such as Linux, Windows, macOS, Android or embedded systems with little or no change in the underlying codebase while still being a native application with native capabilities and speed.

Qt is currently being developed by The Qt Company, a publicly listed company, and the Qt Project under open-source governance, involving individual developers and organizations working to advance Qt.[9][10][11] Qt is available under both commercial licenses[4] and open-source[12] GPL 2.0, GPL 3.0, and LGPL 3.0 licenses.[5][6]

Purposes and abilities

[edit]

Qt is used for developing graphical user interfaces (GUIs) and multi-platform applications that run on all major desktop platforms and mobile or embedded platforms. Most GUI programs created with Qt have a native-looking interface, in which case Qt is classified as a widget toolkit. Non-GUI programs can also be developed, such as command-line tools and consoles for servers. An example of such a non-GUI program using Qt is the Cutelyst web framework.[13]

Qt supports various C++ compilers, including the GCC and Clang C++ compilers and the Visual Studio suite. It supports other languages with bindings or extensions, such as Python via Python bindings[14] and PHP via an extension for PHP5,[15] and has extensive internationalization support. Qt also provides Qt Quick, that includes a declarative scripting language called QML that allows using JavaScript to provide the logic. With Qt Quick, rapid application development for mobile devices became possible, while logic can still be written with native code as well to achieve the best possible performance.

Other features include SQL database access, XML parsing, JSON parsing, thread management and network support.

Releases

[edit]

The latest version of the Qt Framework is Qt 6.9, which was released on 2 April 2025.[16]

Also still supported are — for commercial users — 6.5 LTS, released on 3 April 2023, 6.2 LTS,[17] released on 30 September 2021, and 5.15 LTS, released on 26 May 2020 – long-term support (LTS) versions are generally supported for three years with a commercial license, while 5.15 support was extended to five years for subscription license holders, and so it is supported until 26 May 2025. Additionally the KDE project provides unofficial support for, at least, Qt 5.15, i.e. not just for commercial users.

Qt in use

[edit]

In 2017, the Qt Company estimated a community of about 1 million developers worldwide[18] in over 70 industries.[19]

Desktop UIs

[edit]
KDE's mascot Konqi

Graphical user-interfaces and desktop environments that utilize Qt/QML as widget toolkit:

Embedded and mobile UIs

[edit]
  • Actively developed or maintained
    • AsteroidOS, an open source operating system designed for smartwatches
    • Avionics, Panasonic's in-flight entertainment system[30][31]
    • Sailfish OS, a mobile operating system developed by Jolla
    • Plasma Mobile, a touch-based GUI developed by KDE
    • LuneOS, community-driven successor for Palm/HP webOS
    • Nemo Mobile, based on Mer
    • Lomiri, formerly known as Unity8, a phone UI developed by Ubports, originally by Canonical
    • Tesla Model S in-car UI[32]
    • webOS, a multitask operating system from LG for smart devices like TVs and smartwatches
    • Sky Q, the home entertainment system of Sky plc[33]
  • Available, but inactive
    • MeeGo handset and tablet UX
    • Qtopia, a system by Nokia for embedded and mobile devices

Applications using Qt

[edit]
See also: Category:Software that uses Qt and Category:Proprietary software that uses Qt

Many notable open-source or proprietary cross-platform software are using Qt or QML:

Organizations using Qt

[edit]

Qt is utilized by a wide range of companies and organizations such as

Qt software architecture

[edit]
Example of Qt usage in Linux-based systems

Qt concepts

[edit]

Qt is built on these key concepts:

Complete abstraction of the GUI

[edit]

When first released, Qt used its own paint engine and controls, emulating the look of the different platforms it runs on when it drew its widgets. This made the porting work easier because very few classes in Qt really depended on the target platform; however, this occasionally led to slight discrepancies where that emulation was imperfect. Recent versions of Qt use the native style APIs of the different platforms, on platforms that have a native widget set, to query metrics and draw most controls, and do not suffer from such issues as often.[91] On some platforms (such as MeeGo and KDE) Qt is the native API. Some other portable graphical toolkits have made different design decisions; for example, wxWidgets uses the toolkits of the target platform for its implementations.

Signals and slots

[edit]

Signals and slots are a language construct introduced in Qt for communication between objects[92] which makes it easy to implement the observer pattern while avoiding boilerplate code. The concept is that GUI widgets can send signals containing event information which can be received by other controls using special functions known as slots.

Metaobject compiler

[edit]

The metaobject compiler, termed moc, is a tool that is run on the sources of a Qt program. It interprets certain macros from the C++ code as annotations, and uses them to generate added C++ code with meta information about the classes used in the program. This meta information is used by Qt to provide programming features not available natively in C++: signals and slots, introspection and asynchronous function calls.

Language bindings

[edit]

Qt can be used in several programming languages other than C++, such as Python, Javascript, C# and Rust[93] via language bindings; many languages have bindings for Qt 5 and bindings for Qt 4.

Qt modules

[edit]

Starting with Qt 4.0 the framework was split into individual modules.[94][95] With Qt 5.0 the architecture was modularized even further.[96][97] Qt is now split into essential and add-on modules.[98]

Qt essentials

[edit]
Module Description
Qt Core The only required Qt module, containing classes used by other modules, including the meta-object system, concurrency and threading, containers, event system, plugins and I/O facilities.
Qt GUI The central GUI module. In Qt 5 this module now depends on OpenGL, but no longer contains any widget classes.
Qt Widgets Contains classes for classic widget based GUI applications and the QSceneGraph classes. Was split off from QtGui in Qt 5.
Qt QML Module for QML and JavaScript languages.
Qt Quick The module for GUI applications written using QML2.
Qt Quick Controls Widget like controls for Qt Quick intended mainly for desktop applications.
Qt Quick Layouts Layouts for arranging items in Qt Quick.
Qt Network Network abstraction layer. Complete with support for TCP, UDP, HTTP, TLS, SSL (in Qt 4) and SPDY (since Qt 5.3).
Qt Multimedia Classes for audio, video, radio and camera functionality.
Qt Multimedia Widgets The widgets from Qt Multimedia.
Qt SQL Contains classes for database integration using SQL.
Qt WebEngine A new set of Qt Widget and QML webview APIs based on Chromium.
Qt Test Classes for unit testing Qt applications and libraries.

Qt add-ons

[edit]
Module Description
Active Qt Classes for applications which use ActiveX.
Qt Charts Provides functionality and widgets to plot charts of many kinds
Qt Bluetooth Classes accessing Bluetooth hardware.
Qt D-Bus Classes for IPC using the D-Bus protocol.
Qt NFC Classes accessing NFC hardware. Only officially supported on BlackBerry hardware so far (or N9 in the MeeGo port).
Qt OpenGL Legacy module containing the OpenGL classes from Qt 4. In Qt 5 the similar functionality in Qt GUI is recommended.
Qt Location Classes for accessing GPS and other location services and for mapping and navigation. Split off from the Qt 4 Mobility module of Qt Location. Supported on Android, BlackBerry, iOS, Linux (using GeoClue), Windows and Sailfish OS.
Qt Quick 3D Classes for rendering 3D models, video games, simulations and 3D user interfaces, with a Qt QML API, into a mixed 2D and 3D scene graph.
Qt Script Legacy module for scripting Qt application using ECMAScript/JavaScript. In Qt 5, using similar classes in Qt QML is recommended.
Qt Sensors Classes for accessing various mobile hardware sensors. Used to be part of Qt Mobile in Qt 4. Supported on Android, BlackBerry, iOS, WinRT, Mer and Linux.
Qt Serial Port Classes for access to hardware and virtual serial ports. Supported on Windows, Linux and macOS.
Qt WebChannel Provides access to Qt objects to HTML/Js over WebSockets.
Qt WebKit Qt's WebKit implementation and API.
Qt WebKit Widgets The widget API for Qt WebKit
Qt WebSockets Provides a WebSocket implementation.
Qt XML Legacy module containing classes for SAX and DOM style XML APIs. Replaced with QXmlStreamReader and QXmlStreamWriter classes in Qt Core.
Qt XML Patterns Support for XPath, XQuery, XSLT and XML Schema validation.

Editions

[edit]

There are four editions of Qt available: Community, Indie Mobile, Professional and Enterprise.[99] The Community version is under the open source licenses, while the Indie Mobile, Professional and Enterprise versions, which contain additional functionality and libraries, e.g. Enterprise Controls[99] are commercially sold by The Qt Company.

Supported platforms

[edit]
Main article: List of platforms supported by Qt

Qt works on many different platforms; the following are officially supported:

Platform Description
Linux/Unix
X11 Qt for X Window System (Linux);[100] FreeBSD, NetBSD, OpenBSD, and DragonFly BSD have community support.
Wayland Qt applications can switch between graphical backends like X and Wayland at load time with the -platform command line option.[101][102] This allows a seamless transition of Qt applications from X11 to Wayland. SailfishOS uses Wayland only as it does not have X11.[103]
Android Qt for Android[104] (formerly known as Necessitas).[105]
Embedded Linux Qt for embedded platforms: personal digital assistant, smartphone, etc.[106] Exists as multiple platforms depending on display technology. DirectFB, LinuxFB and EGLFS (EGL Full Screen).
Microsoft platforms
Windows Qt for Microsoft Windows 7, 8, 10, and 11, as well as UWP 10[107]
Windows RT Support for WinRT-based Windows 10 Mobile apps and Windows 10 IoT[108]
Apple platforms
macOS Qt for Apple macOS; supports applications on Cocoa[109]
iOS Qt for iOS platforms (iPhone, iPad)[110]
Other embedded platforms
Integrity Qt for Integrity[111]
QNX Qt for QNX[112][113]
VxWorks Qt for VxWorks.[114][115] Only available under a proprietary (commercial) license. Qt 5.5.
QT for MCUs QT for MCUs[116]

After Nokia opened the Qt source code to the community on Gitorious, various ports appeared. There are also some ports of Qt that may be available, but are not supported anymore. These platforms are listed in List of platforms supported by Qt. See also there for current community support for other lesser known platforms, such as SailfishOS.

Licensing

[edit]

Qt is available under the following free software licenses:[12] GPL 2.0, GPL 3.0, LGPL 3.0 and LGPL 2.1 (with Qt special exception).[5][117] Note that some modules are available only under a GPL license, which means that applications which link to these modules need to comply with that license.[118]

In addition, Qt has always been available under a commercial license, like the Qt Commercial License,[4] that allows developing proprietary applications with no restrictions on licensing.

Qt tools

[edit]
See also: Qt Creator

Qt comes with its own set of tools to ease cross-platform development, which can otherwise be cumbersome due to different set of development tools.

Qt Creator is a cross-platform IDE for C++ and QML. Qt Designer's GUI layout/design functionality is integrated into the IDE, although Qt Designer can still be started as a standalone tool.

In addition to Qt Creator, Qt provides qmake, a cross-platform build script generation tool that automates the generation of Makefiles for development projects across different platforms. There are other tools available in Qt, including the Qt Designer interface builder and the Qt Assistant help browser (which are both embedded in Qt Creator), the Qt Linguist translation tool, uic (user interface compiler), and moc (Meta-Object Compiler).

History of Qt

[edit]

Early developments

[edit]

In the summer of 1990, Haavard Nord and Eirik Chambe-Eng (the original developers of Qt and the CEO and President, respectively, of The Qt Company) were working together on a database application for ultrasound images written in C++ and running on Mac OS, Unix, and Microsoft Windows.[1][119] They began development of "Qt" in 1991, three years before the company was incorporated as Quasar Technologies, then changed the name to Troll Tech and then to Trolltech.[1]

The toolkit was called Qt because the letter Q looked appealing in Haavard's Emacs typeface, and "t" was inspired by Xt, the X toolkit.[1]

The first two versions of Qt had only two flavors: Qt/X11 for Unix and Qt/Windows for Windows.

On 20 May 1995 Trolltech publicly released Qt 0.90 for X11/Linux with the source code under the Qt Free Edition License.[120][121][122] This license was viewed as not compliant with the free software definition by Free Software Foundation because, while the source was available, it did not allow the redistribution of modified versions. Trolltech used this license until version 1.45. Controversy erupted around 1998 when it became clear that the K Desktop Environment was going to become one of the leading desktop environments for Linux. As it was based on Qt, many people in the free software movement worried that an essential piece of one of their major operating systems would be proprietary.

The Windows platform was available only under a proprietary license, which meant free/open source applications written in Qt for X11 could not be ported to Windows without purchasing the proprietary edition.

Becoming free software–friendly

[edit]

With the release of version 2.0 of the toolkit in mid-1999, the license was changed to the Q Public License (QPL), a free software license, but one regarded by the Free Software Foundation as incompatible with the GPL. Compromises were sought between KDE and Trolltech whereby Qt would not be able to fall under a more restrictive license than the QPL, even if Trolltech was bought out or went bankrupt. This led to the creation of the KDE Free Qt foundation,[123] which guarantees that Qt would fall under a BSD-style license should no free/open source version of Qt be released during 12 months.[124][125]

In 2000, Qt/X11 2.2 was released under the GPL v2,[126] ending all controversy regarding GPL compatibility.

At the end of 2001, Trolltech released Qt 3.0, which added support for Mac OS X (now known as macOS). The Mac OS X support was available only in the proprietary license until June 2003, when Trolltech released Qt 3.2 with Mac OS X support available under the GPL.

In 2002, members of the KDE on Cygwin project began porting the GPL licensed Qt/X11 code base to Windows.[127] This was in response to Trolltech's refusal to license Qt/Windows under the GPL on the grounds that Windows was not a free/open source software platform.[128][129] The project achieved reasonable success although it never reached production quality.

This was resolved when Trolltech released Qt 4.0 also for Windows under the GPL in June 2005.[130] Qt 4 supported the same set of platforms in the free software/open source editions as in the proprietary edition, so it is possible, with Qt 4.0 and later releases, to create GPL-licensed free/open source applications using Qt on all supported platforms. The GPL v3 with special exception[131] was later added as an added licensing option. The GPL exception allows the final application to be licensed under various GPL-incompatible free software/open source licenses such as the Mozilla Public License 1.1.

Acquisition by Nokia

[edit]

Nokia acquired Trolltech ASA on 17 June 2008 and changed the name first to Qt Software, then to Qt Development Frameworks.

Nokia focused on turning Qt into the main development platform for its devices, including a port to the Symbian S60 platform. Version 1.0 of the Nokia Qt SDK was released on 23 June 2010.[132] The source code was made available over Gitorious, a community oriented git source code repository, with a goal of creating a broader community using and improving Qt.

On 14 January 2009, Qt version 4.5 added another option, the LGPL,[133] to make Qt more attractive for both non-GPL open source projects and closed applications.[134]

In February 2011, Nokia announced its decision to drop Symbian technologies and base their future smartphones on the Windows Phone platform instead (and since then support for that platform has also been dropped).[135] One month later, Nokia announced the sale of Qt's commercial licensing and professional services to Digia, with the immediate goal of taking Qt support to Android, iOS and Windows 8 platforms, and to continue focusing on desktop and embedded development, although Nokia was to remain the main development force behind the framework at that time.

Merging and demerging with Digia

[edit]

In March 2011, Nokia sold the commercial licensing part of Qt to Digia, creating Qt Commercial.[136] In August 2012, Digia announced that it would acquire Qt from Nokia.[137] The Qt team at Digia started their work in September 2012.[138] They released Qt 5.0 within a month and newer versions every six months with new features and additional supported platforms.

In September 2014, Digia transferred the Qt business and copyrights to their wholly owned subsidiary, The Qt Company, which owns 25 brands[139] related to Qt. In May 2016, Digia and Qt demerged completely into two independent companies.[140]

The Qt Project and open governance

[edit]
Main article: Qt Project

Qt 5 was officially released on 19 December 2012. This new version marked a major change in the platform, with hardware-accelerated graphics, QML and JavaScript playing a major role. The traditional C++-only QWidgets continued to be supported, but did not benefit from the performance improvements available through the new architecture.[141] Qt 5 brings significant improvements to the speed and ease of developing user interfaces.[142]

Framework development of Qt 5 moved to open governance at qt-project.org, which made it possible for developers outside Digia to submit patches for review.[143]

Qt contributors

[edit]
Distribution of non-Digia Qt contributors (2013, Week 18)

Aside from The Qt Company, many organizations and individuals using Qt as their development platform participate in the open development of Qt via the Qt Project.[144]

One such Qt contributor is Klarälvdalens Datakonsult AB, a Swedish Qt consulting company.[145] KDAB is involved in many areas, including maintenance of several components.[146][147]

Together with RIM/BlackBerry, KDAB is maintaining the QNX and BlackBerry 10 ports of Qt.[144][148]

Another participator is Intel, contributing for example Wayland support.[149] AudioCodes maintains IBM ClearCase support in Qt Creator.[150]

As a heavy user of Qt, the KDE project submits many patches and features from its developer library KDE Frameworks back to Qt.[151]

See also

[edit]

Bibliography

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Qt (software)

View on Grokipedia
from Grokipedia
Qt is a modular, cross-platform C++ application framework designed for developing graphical user interfaces and software components that deploy across desktop, mobile, embedded, and web platforms with minimal platform-specific adjustments.[1][2] Originating from a 1991 project by Norwegian developers Haavard Nord and Eirik Chambe-Eng at Trolltech, Qt saw its first public release in 1995 and evolved through ownership changes, including Nokia's 2008 acquisition of Trolltech and subsequent transfers to Digia and The Qt Company, which now maintains its development.[3][4] The framework's core strengths lie in its comprehensive APIs for networking, multimedia, 3D rendering, and database integration, complemented by tools such as the Qt Creator integrated development environment and QML for declarative user interface design, facilitating efficient code reuse via a "write once, deploy everywhere" model.[5][6] Qt's dual-licensing structure—offering open-source options under GPLv2/GPLv3 and LGPLv3 alongside commercial licenses—has supported its widespread use in free software ecosystems like the KDE desktop environment and proprietary applications from industries including automotive, medical devices, and consumer electronics, though past licensing policy shifts have occasionally sparked community debates over accessibility for non-commercial developers.[7][8][9]

Core Features and Capabilities

Primary Purposes

Qt serves primarily as a cross-platform application framework for developing graphical user interfaces (GUIs) and full-featured applications that operate consistently across diverse operating systems, including desktop environments like Windows, macOS, and Linux, as well as mobile platforms such as Android and iOS, and embedded systems.[1] This portability stems from its object-oriented class library written in C++, which abstracts platform-specific details, allowing developers to maintain a single codebase for multiple targets while achieving native performance and appearance.[1] Beyond GUIs, Qt enables the creation of non-graphical software, such as console applications, servers, and networked tools, through modules supporting concurrency, database connectivity, multimedia processing, and web integration, making it suitable for backend services and data-intensive tasks in over 70 industries, from automotive to medical devices.[10] Its design emphasizes reliability and efficiency, powering applications on billions of devices worldwide by providing APIs for rapid prototyping and deployment in resource-constrained environments like IoT and real-time systems.[10] The framework's declarative UI language, QML, complements its imperative C++ core, facilitating modern, responsive interfaces for touch-based and animated applications, which broadens its utility in consumer software, enterprise tools, and safety-critical embedded solutions requiring certification compliance.[1] Qt's modular architecture supports both open-source and commercial licensing, enabling scalable development from prototypes to production-scale deployments.[8]

GUI and Application Development Abilities

Qt provides robust capabilities for graphical user interface (GUI) development through its Qt Widgets module, which offers a comprehensive hierarchy of C++ classes for constructing traditional desktop interfaces, including primitives like buttons, labels, and sliders, as well as advanced layout managers and container widgets for responsive designs. These widgets support custom painting via the QPainter class and can be styled uniformly across platforms using Qt Style Sheets (QSS), a syntax akin to CSS for defining visual properties such as colors, fonts, and borders. Event handling is facilitated by the signals and slots mechanism, allowing developers to connect user interactions to application logic without tight coupling, thus promoting modular code.[11] For modern, fluid user experiences, particularly in mobile and embedded contexts, Qt Quick employs QML, a declarative language that integrates JavaScript for behavior logic with scene graph rendering for hardware-accelerated animations and transitions. QML components enable the creation of reusable UI elements with built-in support for touch gestures, particle effects, and state machines, rendering efficiently via OpenGL ES or Vulkan backends. This approach separates declarative UI description from imperative C++ backend code, streamlining development for cross-platform applications that maintain a native look and feel through platform-specific themes or custom styling.[12] Application development is enhanced by integrated tools within Qt Creator, the official IDE, which includes visual editors like Qt Designer for widget-based UIs and Qt Quick Designer for QML prototyping, alongside code editing, debugging, and profiling features tailored for efficient iteration.[13] Qt's internationalization support via the Qt Linguist tool allows for dynamic translation of strings and right-to-left layouts, while accessibility features comply with standards like WCAG through screen reader integration and keyboard navigation. These abilities extend to embedding multimedia via Qt Multimedia for video playback and Qt WebEngine for web content, enabling full-featured applications from single codebases deployable to desktops, mobiles, and embedded systems without recompilation per platform.[14]

Cross-Platform and Non-GUI Extensions

Qt enables the development of applications that compile and run natively across diverse platforms, including desktop operating systems such as Microsoft Windows, macOS, and Linux distributions, as well as mobile platforms like Android and iOS, and embedded systems ranging from microcontrollers to real-time operating systems.[15] This cross-platform compatibility is achieved through abstractions that map to platform-specific implementations, allowing a single codebase to target multiple environments with minimal modifications while preserving native look-and-feel and performance where GUI elements are involved.[1] For instance, Qt's build system supports compilation for over 20 platforms, facilitating deployment from high-end desktops to resource-constrained devices without requiring platform-specific rewrites.[16] Qt achieves cross-platform consistency through its Qt Platform Abstraction (QPA) layer, which provides platform-specific plugins (backends) for rendering and window management. On Linux, Qt supports the X11 protocol via the XCB backend and the Wayland protocol natively, allowing applications to run seamlessly in either environment without code changes. This abstraction extends to handling differences in display compositing, input handling, and HiDPI scaling across Windows (Win32/DirectComposition), macOS (Cocoa/AppKit), and Linux display servers. For complex UI elements like dockable widgets and panels, Qt's ecosystem includes libraries such as KDDockWidgets, which offer advanced, customizable docking systems that work across platforms, including Wayland and X11 on Linux, by relying on Qt's unified API rather than direct protocol interactions. Beyond graphical interfaces, Qt's architecture supports non-GUI applications through modules that operate independently of any windowing system or display server. The Qt Core module furnishes essential non-graphical functionality, including container classes (e.g., QVector, QMap), string handling with Unicode support, file I/O operations, event loops via QCoreApplication, and threading primitives for concurrent programming.[17][6] These features enable the creation of console-based tools, servers, and backend services that execute cross-platform, such as data processing pipelines or networked daemons, without linking to GUI dependencies. Qt Core also integrates JSON and XML parsing, internationalization via translation files, and plugin loading mechanisms, which are utilized in environments lacking graphical output, like headless servers or embedded controllers.[17] Additional non-GUI extensions extend Qt's utility for specialized tasks. The Qt Network module provides classes for TCP/UDP sockets, HTTP clients/servers, SSL/TLS encryption, and DNS resolution, supporting cross-platform network programming for applications like RESTful APIs or IoT gateways.[6] Qt SQL offers database connectivity abstractions for engines including SQLite, PostgreSQL, and MySQL, with query preparation and transaction handling that abstract vendor-specific details.[17] Qt Concurrent facilitates parallel execution of tasks using thread pools and futures, while Qt Test delivers a framework for unit and integration testing without graphical components.[18] These modules, combinable with Qt Core, power non-visual use cases such as automated build systems, simulation engines, or data acquisition software on platforms from Linux servers to ARM-based embedded hardware.[19] Developers can configure builds to exclude GUI modules entirely, reducing binary size and dependencies for pure backend deployments.[20]

Technical Architecture

Fundamental Concepts

Qt's architecture is built upon an event-driven programming model, where applications respond to user inputs, system events, and inter-object communications through a central event loop managed by classes like QEventLoop. This loop processes events such as mouse clicks, key presses, and timers, ensuring responsive behavior across platforms without blocking the main thread.[21] The QApplication or QGuiApplication class typically initializes this loop via its exec() method, which blocks until the application exits.[22] At the core is the meta-object system, a compile-time extension to C++ that adds runtime introspection, dynamic properties, and the signals-and-slots mechanism for decoupled object communication. Classes inheriting from QObject—the base class for nearly all Qt objects—must include the Q_OBJECT macro to enable this system, which is processed by the Meta-Object Compiler (moc) to generate additional code for features like type-safe signal emission and slot invocation.[23] This system supports runtime type information via QMetaObject, allowing queries on class hierarchies, methods, and properties, and facilitates thread-safe cross-thread signal delivery using queued connections.[22] Signals and slots form Qt's primary inter-object communication paradigm, promoting loose coupling over direct method calls or callbacks. A signal is emitted in response to an event (e.g., a button click), and connected slots in other objects execute automatically, with the connection established via QObject::connect() supporting direct, queued, or lambda-based variants for flexibility in single- or multi-threaded scenarios.[11] This mechanism is integral to Qt's object model, enabling reactive designs where changes in one object propagate without explicit dependencies, and it underpins higher-level abstractions like model/view delegates for data-driven UIs.[24] For declarative UI development, QML (Qt Modeling Language) introduces a JavaScript-like syntax layered atop the meta-object system, defining UI hierarchies through property bindings and state machines rather than imperative code. QML objects, instantiated via the QML engine, leverage signals/slots for behavior and integrate with C++ backends through exposed QObject-derived types, supporting dynamic updates and animations via implicit binding reevaluation on property changes.[25] This hybrid approach separates presentation from logic, with the scene graph renderer optimizing graphics rendering independently of the CPU-bound event loop.[26]

Core Modules

QtCore provides the foundational non-graphical classes and utilities essential for all Qt applications, including the meta-object compiler (moc) for runtime type information, the signals and slots mechanism for event-driven communication, the event loop for handling user input and timers, and container classes like QVector and QString for data management.[27] These components ensure platform independence by abstracting operating system specifics, such as threading via QThread and file I/O through QFile.[27] QtGui builds upon QtCore to deliver core graphical primitives, encompassing 2D vector graphics, font rendering, image handling, and input device abstractions like mouse and keyboard events, while supporting hardware-accelerated rendering through integration with OpenGL and Vulkan. It includes classes such as QPainter for drawing operations, QImage for pixel-based manipulation, and QFont for typography, forming the basis for higher-level UI frameworks without relying on platform-specific APIs. QtNetwork extends the core with classes for TCP/IP socket programming, HTTP client/server operations via QNetworkAccessManager, and support for protocols like FTP and SSL/TLS encryption, enabling robust cross-platform networking without direct OS socket calls. QtSql facilitates database connectivity using SQL drivers for systems like SQLite, MySQL, and PostgreSQL, with QSqlDatabase for connection management and QSqlQuery for executing queries and handling results in a driver-agnostic manner. These modules, classified as Qt Essentials, are actively maintained, source- and binary-compatible across Qt 6 series (except testing utilities), and available on all supported platforms, serving as the minimal set for building functional applications.[17]

Extended Modules and Add-Ons

Qt Add-On modules extend the core Qt framework by providing specialized functionality for targeted use cases, such as data visualization, hardware integration, and multimedia processing, often with platform-specific implementations. Unlike Qt Essentials, which form the foundational cross-platform components available on all supported development and target platforms, Add-Ons may have limited availability, varying compatibility guarantees, and dependencies on specific operating systems or hardware. These modules are accessible through Qt installers and are designed to integrate seamlessly with the core libraries, enabling developers to build feature-rich applications without external dependencies.[17][28] Key examples include Qt Charts, which supplies C++ and QML types for rendering interactive 2D charts like bar, line, and pie graphs, supporting both static and dynamic data updates. Qt Bluetooth enables low-level access to Bluetooth hardware for tasks such as device discovery and data transfer, but is restricted to platforms with compatible Bluetooth stacks, including Android, iOS, Linux, macOS, and Windows. Qt Multimedia offers high-level APIs for capturing, processing, and playing audio and video, including camera controls and effects, with backend support varying by platform (e.g., GStreamer on Linux, AVFoundation on iOS).[17][28][14] Other notable Add-Ons encompass Qt Quick 3D for integrating 3D models and scenes into Qt Quick applications via a declarative QML API, suitable for simulations and user interfaces; Qt WebEngine, which embeds Chromium-based web content rendering for hybrid desktop and embedded apps; and Active Qt, limited to Windows for exposing Qt widgets as ActiveX controls or COM objects. Licensing for these modules follows Qt's dual model: open-source editions under LGPLv3 or GPLv3, allowing free use with compliance requirements like dynamic linking and source disclosure for modifications, while commercial licenses remove copyleft obligations for proprietary software but require paid subscriptions starting from professional tiers that unlock full Add-On access. Certain modules, such as Qt WebEngine, carry additional GPL-derived restrictions due to their Chromium integration, potentially necessitating commercial options for closed-source deployments.[17][29][30]

Editions and Platform Support

Qt is distributed in two primary editions: the open-source Community Edition, licensed under the GNU General Public License (GPL) version 3 or the Lesser GPL (LGPL) version 3, and commercial editions tailored for proprietary development.[7] The Community Edition permits free use, modification, and distribution for open-source projects, but imposes obligations such as dynamic linking for proprietary applications under LGPL to avoid requiring source code disclosure, and full source availability under GPL.[7] Commercial editions, including options for Application Development (Professional and Enterprise tiers) and Device Creation (Professional, Enterprise, and Distribution tiers), eliminate these open-source compliance requirements, granting full intellectual property control and access to enhanced support, indemnity, and tools like advanced profiling without subscription-based open-source restrictions.[7] The underlying codebase remains identical across editions, with differences confined to licensing terms and ancillary services.[7] Qt provides extensive cross-platform support, with the Qt Company offering commercial support for verified configurations across desktop, mobile, embedded, real-time operating systems (RTOS), and web environments.[31] On desktop platforms, Qt targets Windows 10 (version 1809 and later) and Windows 11 using MSVC 2022 or MinGW-w64 13.1; macOS 13 and subsequent versions with Xcode 15 and the macOS 14 SDK; and Linux distributions including Ubuntu 22.04 to 24.04, Red Hat Enterprise Linux 8.6 to 9.4, openSUSE 15.6, SUSE Linux Enterprise Server 15 SP6, and Debian 11.6, compiled with GCC versions 9 through 13.[31] Mobile development is enabled for Android 9 through 15 using Clang 17.0.2 from NDK r27c, JDK 17, and Gradle 8.14.2; and iOS 17 and later with Xcode 15 and the iOS 17 SDK.[31] For embedded and RTOS applications, Qt features tiered support levels, with Tier 1 reference targets like Intel NUC, NVIDIA Jetson AGX Orin, NXP i.MX 8QuadMax, Qualcomm SA8155P, and Raspberry Pi 5 under Yocto 5.2 or Android Automotive OS 10-14 receiving full commercial validation.[31] Tier 2 verified targets include additional hardware such as NXP i.MX 93, Raspberry Pi 4, and ST STM32MP15, while Tier 3 covers broader compatibility with devices like NVIDIA Jetson Orin Nano and StarFive VisionFive 2.[31] RTOS support encompasses INTEGRITY 19.0.13, QNX 7.1-8.0, FreeRTOS, VxWorks 24.03, and Zephyr.[31] WebAssembly enables browser-based deployment on Chrome, Edge, Firefox, and Safari using Emscripten 4.0.7.[31] Platform configurations are regularly updated, with commercial support limited to those explicitly listed to ensure stability and performance.[31]

Development Tools

Qt Creator serves as the primary integrated development environment (IDE) for Qt applications, offering a cross-platform toolset that includes a code editor with syntax highlighting and autocompletion, an integrated debugger, and project management features.[5][13] It supports development for desktop, mobile, embedded systems, and web via WebAssembly, with built-in tools for version control, building multiple targets, and emulation of devices.[5][13] Recent enhancements include the Qt AI Assistant, which provides code autocompletion, optimization suggestions, and automated generation of test cases and documentation.[5] For user interface design, Qt Creator integrates Qt Designer, a drag-and-drop tool for creating GUI forms in Qt Widgets or QML, while Qt Design Studio offers advanced capabilities for prototyping 2D and 3D interfaces, facilitating collaboration between designers and developers by converting visual designs into deployable code.[32][13] Internationalization is supported through Qt Linguist, which manages translation files and handles string extraction for multilingual applications.[33] Qt's build system historically primarily utilized qmake, a tool that generates platform-specific Makefiles from .pro project files, automating compilation steps including invocation of preprocessors.[34] However, since Qt 6, CMake has become the preferred and primary build system due to its flexibility for complex, cross-platform projects, with official CMake support eliminating the need for custom scripts and enabling seamless integration with Qt's modules—as Qt itself now builds using CMake.[34][35] Qt also provides essential command-line utilities: the Meta-Object Compiler (moc) processes classes with Q_OBJECT macros to enable signal-slot mechanisms and introspection; the User Interface Compiler (uic) converts .ui files from Qt Designer into C++ or QML code; and the Resource Compiler (rcc) embeds binary resources like images and icons into executables.[36][37] These tools are invoked automatically by qmake or CMake during the build process, ensuring efficient handling of Qt-specific features without manual intervention.[37] Testing is facilitated by the Qt Test framework, which allows unit testing of Qt code through QTest macros for assertions, data-driven tests, and benchmarking, integrable into Qt Creator's testing tools.[6] Profiling and debugging extensions, such as the QML Profiler and GammaRay, further aid in performance analysis and runtime inspection.[38]

Licensing and Governance

Evolution of Licensing Models

Qt originated as a proprietary software framework developed by Trolltech, with its first commercial release occurring on September 20, 1995.[39] Initially available solely under a commercial license, this model restricted usage to paying customers and limited community contributions, as source code was not freely accessible.[4] To broaden developer adoption and counter criticisms regarding openness—particularly amid debates over its compatibility with the GNU General Public License (GPL) used in projects like KDE—Trolltech introduced an open-source licensing option in 1999. Qt 2.0 for X11 was released under the Q Public License (QPL) on June 26, 1999, a permissive license drafted by Trolltech that allowed free use, modification, and distribution while requiring derivative works to be licensed under QPL or compatible terms.[40] [39] However, the QPL's non-standard nature and lack of OSI approval led to compatibility concerns, prompting Trolltech to add GPL version 2 coverage starting with Qt 2.2 on December 7, 2000, enabling integration with GPL-licensed software but still requiring full source disclosure for linked applications.[40] This established a dual-licensing approach: open-source (QPL/GPL) for non-commercial or fully open projects, and commercial for proprietary development. The acquisition of Trolltech by Nokia on June 17, 2008, accelerated a shift toward more flexible open-source terms to promote Qt's use in embedded and mobile ecosystems, including proprietary applications.[39] Nokia relicensed Qt 4.5, released on March 4, 2009, under the GNU Lesser General Public License (LGPL) version 2.1 alongside existing GPL and commercial options, introducing a "Qt LGPL Exception" to explicitly permit dynamic linking with closed-source code without mandating source release of the application.[41] [39] This permissive adjustment addressed prior GPL limitations, significantly expanding Qt's appeal for commercial software while maintaining copyleft protections for the framework itself.[42] Following Nokia's divestiture of Qt assets—first the commercial licensing business to Digia in March 2011, then the full technology and business in August 2012—the dual model persisted under Digia (later rebranded The Qt Company in 2014).[43] [44] LGPL version 3 was added as an option in subsequent releases, offering enhanced patent protections, though v2.1 remained prevalent for legacy compatibility.[45] The framework's core modules have stayed under these open-source terms, with commercial licenses providing indemnity, support, and access to proprietary extensions, reflecting an ongoing balance between community-driven development and revenue generation.[46] This evolution from restrictive proprietary terms to multi-licensed openness has underpinned Qt's cross-platform proliferation, though it has occasionally sparked debates over the sustainability of free editions amid commercial prioritization.[47]

Open Source and Commercial Options

Qt offers dual licensing, providing both open-source and commercial options to accommodate different development needs, particularly for proprietary versus open-source software. The open-source licenses, available through the Qt Community Edition, include the GNU General Public License version 3 (GPLv3) and the GNU Lesser General Public License version 3 (LGPLv3), which permit free use, modification, and distribution subject to compliance with their terms.[29] Under LGPLv3, developers can create proprietary applications by dynamically linking to Qt libraries, provided they distribute the application's object code and allow users to replace the linked Qt modules with modified versions; static linking, however, typically requires releasing the application's source code to meet LGPL obligations.[29] GPLv3 mandates that any software incorporating Qt under this license must also be released under GPLv3, making it suitable primarily for fully open-source projects.[48] Commercial licenses, offered by The Qt Company, enable unrestricted proprietary development without open-source compliance requirements, granting full intellectual property control, indemnity against patent claims, and access to premium support, tools, and features not available in the community edition.[7] These are structured as subscription-based agreements, typically for 12 or 36 months with auto-renewal, and are categorized into offerings such as Application Development (for desktop and mobile apps), Device Creation (for embedded systems), and specialized tools like Qt Design Studio, each with Professional and Enterprise tiers differentiated by support levels and deployment scale.[7] Developers must purchase commercial licenses for closed-source applications to avoid LGPL/GPL restrictions, especially in scenarios involving static linking or integration where source disclosure would compromise competitive advantages.[48] The choice between options hinges on project goals: open-source licenses suffice for non-commercial or fully open projects, fostering community contributions, while commercial licenses are essential for enterprises seeking to protect proprietary code and streamline large-scale deployments, as evidenced by their adoption in industries requiring certified, support-backed toolkits.[48] Since Qt 5.4 (released in 2015), LGPLv3 has been the default open-source option, aligning with modern free software principles while preserving commercial viability.[29] No fundamental changes to this dual model have occurred as of 2025, though The Qt Company periodically updates terms to reflect evolving compliance needs.[7]

Licensing Controversies and Changes

In 2012, following Digia's acquisition of Qt assets from Nokia, initial concerns arose within the open-source community regarding potential shifts away from permissive licensing toward stricter commercial controls, though Digia publicly committed to maintaining the dual-licensing model including LGPLv2.1 with the existing special exception that eases dynamic linking for proprietary applications.[49] No immediate revocation of open-source terms occurred, but the transition heightened scrutiny over the balance between community contributions and corporate governance.[50] A significant controversy emerged in January 2020 when The Qt Company announced updates to its offerings, mandating valid Qt accounts for all binary downloads starting February 2020 and restricting initial access to long-term support (LTS) releases and offline installers to commercial licensees, with Qt 5.15 as the inaugural example.[51] Open-source users faced delays of up to one year for LTS availability, aligning with LGPL obligations but criticized by KDE and other contributors for undermining stability and security updates in non-commercial projects.[52] The changes also introduced a $499 annual license tier for small businesses with under $100,000 revenue and fewer than five employees, framed by the company as necessary to fund development amid rising costs.[51] These 2020 adjustments intensified debates over The Qt Company's prioritization of revenue—via subscription-based commercial models—potentially at the expense of open-source sustainability, with community voices, including KDE's, invoking the KDE Free Qt Foundation agreement to ensure fallback to BSD licensing if free releases lapse beyond LGPL timelines.[53] In response to feedback, the company revised commercial terms in February 2022, granting perpetual distribution rights post-subscription to mitigate risks of halted deployments upon license expiration.[54] For Qt 6, released in 2021, licensing retained dual options under LGPLv3 for open source (with the special exception) alongside commercial subscriptions, but certain modules and add-ons became exclusively commercial for proprietary embedded or device creation use cases, limiting open-source access to core features.[45] This modular approach, while enabling broader commercial revenue, prompted ongoing community discussions about dependency risks, though the Qt Project's governance structure—overseen by The Qt Company with contributor input—has sustained releases without full proprietary lock-in.[30]

Governance Structure and Contributors

The Qt Project employs a meritocratic and consensus-based governance model structured around five escalating levels of involvement: Users, who provide feedback; Contributors, who submit patches via issue trackers and code review tools; Approvers, who review and decide on the acceptance of contributions based on technical merit and alignment with project goals; Maintainers, who oversee specific components for quality, strategic direction, and review of unhandled submissions; and Chief Maintainers, who lead overall vision, resolve disputes, and nominate new Maintainers.[55] Decisions operate under a "lazy consensus" principle, where proposals are accepted unless explicitly opposed within a reasonable period, such as 15 working days for Maintainer nominations, escalating to Maintainer or Chief Maintainer arbitration if needed; contributions are reviewed through a code review system and accepted per the project's commit policy, with feedback provided for rejections.[55] Development of the Qt framework occurs collaboratively between The Qt Company, a publicly traded entity that holds commercial licensing rights and leads proprietary enhancements, and the open-source Qt Project, which coordinates community-driven efforts for the free editions.[56] The KDE Free Qt Foundation, established as a Norwegian non-profit, safeguards Qt's availability for free software by holding perpetual license agreements with Qt Group, Digia, and Nokia; its board comprises two voting members each from KDE e.V. (Albert Astals Cid and Olaf Schmidt-Wischhöfer) and Qt Group (Juhapekka Niemi and Tuukka Turunen), plus advisory non-voting roles for original Trolltech founders Eirik Chambe-Eng and Haavard Nord, enabling relicensing under open terms like BSD if the free edition is discontinued.[57] Contributors to the Qt Project include both internal Qt Company staff and external participants from organizations like KDE, with historical roots in Trolltech's founding team; in 2024, the project recorded 14,903 total commits, of which 2,681 (18%) were external from 180 contributors, including 62 new participants submitting 133 commits.[58] Leading external individuals that year included Thiago Macieira (455 commits), Christian Ehrlicher (299), and Ahmad Samir (232), often affiliated with community partners such as KDE; contributions encompass code, documentation, bug reports, and user support, facilitated through platforms like Gerrit for reviews and annual events like the Qt Contributor Summit.[58]

Release History

Early Versions (Qt 1 to Qt 4)

Qt was initially developed by Norwegian students Haavard Nord and Eirik Chambe-Eng, who conceived the framework in 1990 while sitting on a park bench in Trondheim to simplify cross-platform GUI application development using C++.[39] Trolltech AS, the company formed to commercialize Qt, was incorporated on March 4, 1994, initially under the name Quasar Technologies before renaming to Trolltech.[59] The first public release, Qt 0.90, occurred on May 20, 1995, targeting X11 on Linux and Unix systems under a proprietary commercial license, with a restricted "free edition" available for non-commercial use that prohibited modification or redistribution of source code.[4] This early version provided foundational widgets like buttons, labels, and dialogs, along with the innovative signals-and-slots mechanism for event handling and loose coupling between objects, enabling reactive, event-driven programming without manual polling.[60] Qt 1.0, the first stable release, arrived on September 24, 1996, expanding on the preview with improved stability, additional widgets such as tab dialogs and multiline editors, and support for basic layouts like boxes.[40] Subsequent 1.x updates through the late 1990s, up to version 1.45 in 1999, added features like sliders, tooltips, and printer support, while extending portability to Windows platforms alongside X11.[40] Licensing remained dual: commercial for proprietary applications and the restrictive free edition for open-source hobbyists, sparking debates in the Linux community over its compatibility with the GPL, as Trolltech initially resisted full open-source terms to protect revenue.[4] By 1999, pressure from projects like KDE led Trolltech to offer Qt under the GPL for Linux/X11, though Windows versions stayed proprietary until later.[61] Qt 2.0, released in November 2000, marked a maturation with Qt Designer for visual UI building, enhanced internationalization via Unicode support, and broader platform coverage including Windows CE and better ActiveX integration on Windows.[62] Version 2.2 in 2000 introduced full GPL v2 compatibility for X11, resolving prior licensing friction and boosting adoption in open-source desktop environments like KDE.[61] Qt 3.0 followed in October 2001, adding native Mac OS X support (initially via Carbon, later Cocoa), accessibility features for screen readers, and stylesheet-based theming for customizable appearances without recompilation.[62] Qt 3.x releases through 2004 emphasized performance optimizations, XML handling via QtXml, and network modules, solidifying Qt's role in cross-platform tools like the Opera browser and early mobile prototypes, while maintaining backward compatibility within the series.[60] Qt 4.0, launched on June 28, 2005, represented a fundamental redesign, breaking binary compatibility with Qt 3 to enable cleaner architecture and future-proofing; applications required recompilation and partial API porting.[63] Key advancements included the model/view framework for delegating data presentation to customizable delegates, reducing widget bloat in complex UIs; template-based containers like QVector replacing Qt 3's non-templated variants for type safety and efficiency; and QGraphicsView for scalable 2D graphics scenes supporting animations and OpenGL acceleration.[64] Additional modules covered scripting with QtScript (ECMAScript-compliant), phonetic support for input methods, and a phonemizer for text-to-speech, alongside improved multi-threading and platform abstraction for embedded systems.[40] This version shifted toward modularity with separate libraries for graphics, multimedia, and SQL, facilitating selective inclusion and paving the way for Qt's expansion beyond desktops.[64] Qt 4's LGPL licensing option, introduced in 2009 for version 4.5, further broadened commercial viability by allowing proprietary linking without full source disclosure.[62]

Qt 5 and Transition to Modular Design

Qt 5, released on December 19, 2012, represented a foundational redesign of the framework, emphasizing modularity to enhance maintainability, licensing flexibility, and adaptability for diverse platforms including embedded systems.[40] Unlike the more monolithic structure of Qt 4, where components were tightly bundled, Qt 5 decomposed the library into discrete modules, each functioning as an independent repository. This shift facilitated granular development, allowing developers to include only necessary components, thereby reducing binary size and improving performance in resource-constrained environments.[65] [66] Key architectural changes included separating widgets from the QtGui module into a dedicated QtWidgets module, enabling optional widget support without mandating it for all applications, particularly those leveraging the new QML-based declarative UI paradigm.[66] Essential modules such as QtCore (for core non-GUI functionality) and QtGui (focused on rendering and input) formed the baseline, while add-on modules like QtQml, QtQuick, and QtNetwork could be adopted selectively.[67] This modularity aligned with LGPL licensing requirements, as it permitted isolating proprietary extensions or excluding GPL-incompatible elements, addressing prior constraints in commercial deployments.[68] The transition also streamlined contribution workflows under the Qt Project's governance, with modules maintained in separate Git repositories to lower barriers for external developers and vendors.[65] However, porting from Qt 4 required adjustments, such as updating build systems to handle module-specific configurations and addressing deprecated APIs, though the core C++ API remained largely backward-compatible for widgets-based code.[66] By Qt 5.0's stable release, this design proved instrumental in supporting hardware-accelerated graphics via a new scene graph renderer, further decoupling rendering from platform specifics.[69]

Qt 6 and Modern Enhancements

Qt 6, released on December 8, 2020, represents a significant evolution from Qt 5, emphasizing improved performance, modern C++ standards, and streamlined APIs while discontinuing backward compatibility to eliminate legacy code.[70][71] The framework adopts C++17 as the baseline, enabling features like structured bindings and inline variables for enhanced code readability and efficiency.[72] A new rendering pipeline reduces memory usage and boosts responsiveness, particularly in graphical applications, by leveraging modern hardware acceleration more effectively.[73] Key enhancements include refinements to QML for declarative UI development, with better integration of JavaScript and support for item views, alongside updated native styles for platforms like iOS and Android.[74] Qt 6 introduces or improves modules such as Qt Graphs for data visualization and Qt HTTP Server for backend services, while enhancing font rendering, emoji support, and vector animations in releases like 6.9 and 6.10.[75][76] Accessibility features expanded in Qt 6.10, incorporating ready-made high-contrast themes, simplified data exchange, and FlexBoxLayout for responsive designs.[77] Subsequent long-term support (LTS) versions, such as Qt 6.8 released on October 8, 2024, deliver over 500 bug fixes and performance optimizations without requiring code changes, alongside new tools like QChronoTimer for precise timing and svgtoqml for SVG-to-QML conversion.[78] Qt 6.10, released on October 7, 2025, further advances Android compatibility, vector graphics with CSS keyframes and Lottie animations, and Python bindings via enhanced Shiboken support.[77][79] These updates prioritize scalability for embedded, desktop, and mobile deployments, though developers must address porting challenges like removed deprecated APIs from Qt 5.15.[71]

Recent Releases and Maintenance (2020–2025)

Qt 6.0.0, the first major release of the Qt 6 series, was launched on December 8, 2020, introducing a modular architecture, adoption of C++17 as the baseline standard, and enhancements to QML for improved declarative UI development, alongside deprecations of legacy modules to streamline the framework for modern platforms.[80] This release marked a shift from Qt 5 by removing support for outdated technologies like OpenGL ES 2.0 and emphasizing Vulkan and Metal for graphics rendering, with binary compatibility guaranteed within minor versions but not across major ones.[80] Subsequent minor releases followed a biannual cadence, typically in spring (March/April) and fall (September/October), incorporating feature additions, bug fixes, and performance optimizations while maintaining source compatibility with prior Qt 6 minors.[80] Key versions included Qt 6.2 LTS on January 7, 2022, providing three years of commercial support; Qt 6.5 LTS on March 31, 2023, extending support to 2026; and Qt 6.7 on March 31, 2024.[80] Qt 6.8 LTS, released October 8, 2024, introduced five-year commercial support starting from this version, reflecting extended maintenance commitments for enterprise users.[80] In 2025, Qt 6.9 arrived on March 31, followed by Qt 6.10 on October 7, each supported with patch releases for security and stability until the subsequent minor, with latest patches like 6.9.3 addressing regressions and platform-specific issues.[80] Long-term support releases received prioritized patches, including commercial-exclusive fixes, while open-source variants relied on community contributions via the Qt Project.[80] Maintenance for Qt 5.15 LTS, initiated May 26, 2020, continued through this period with patches available to open-source users via KDE's collection, ensuring legacy compatibility amid the Qt 6 transition.[81]
VersionRelease DateTypeSupport End (Commercial)
6.02020-12-08MajorEnded (ES available)
6.2 LTS2022-01-07LTSEnded (ES available)
6.5 LTS2023-03-31LTS2026-03-30
6.62023-10-07MinorEnded (ES available)
6.72024-03-31MinorEnded (ES available)
6.8 LTS2024-10-08LTS2029-10-08
6.92025-03-31Minor2026-03-31
6.102025-10-07Minor2026-10-07
Extended support options were offered for ended releases, and patch releases (e.g., 6.8.4, 6.5.10) focused on critical fixes without introducing new features.[80] The Qt Company coordinated these efforts through the Qt Project's governance, balancing innovation with stability for cross-platform deployment in desktop, embedded, and mobile environments.[80]

Adoption and Impact

Notable Applications and Software

The KDE Plasma desktop environment, a prominent open-source graphical user interface for Linux and other Unix-like systems, is fundamentally built using the Qt framework, leveraging its widgets and QML for modern user interfaces.[82] Telegram Desktop, the official cross-platform client for the Telegram messaging service, is developed with Qt, enabling consistent performance across Windows, macOS, and Linux.[83][84] Oracle VM VirtualBox, a widely used open-source virtualization platform, utilizes Qt for its graphical frontend, facilitating cross-platform compatibility in managing virtual machines.[85] Autodesk Maya, a professional 3D computer animation, modeling, simulation, and rendering software, incorporates Qt as its UI toolkit, allowing extensive customization of interfaces through Qt controls and plugins.[86] AMD Radeon Software, the graphics driver and management suite for AMD GPUs, employs Qt to deliver its user interface, as highlighted in Qt's success stories for optimizing graphics package development.[87] In multimedia, VLC media player versions from 3.0 onward use Qt for their graphical interface, supporting playback across multiple platforms with Qt's multimedia modules.[88] Scribus, an open-source desktop publishing application, relies on Qt for its cross-platform document layout and PDF creation capabilities.[89] Beyond desktop software, Qt powers embedded applications such as Volkswagen's infotainment systems, where it reduced memory consumption by 50% in 5-inch displays, and Koenigsegg's supercar software for high-performance dashboards.[87]

Organizational and Industry Usage

Qt is adopted by leading organizations in sectors demanding robust, cross-platform graphical user interfaces and real-time performance, including automotive, medical, and entertainment industries. Companies leverage its modular architecture for developing applications that deploy across desktop, embedded, and mobile environments while maintaining consistency and efficiency.[90] In the automotive industry, Qt facilitates human-machine interface (HMI) development for software-defined vehicles, enabling rapid prototyping, advanced graphics, and integration with middleware. Mercedes-Benz, Hyundai Motor Company, Stellantis, Ducati, and Koenigsegg utilize Qt for digital cockpits, infotainment systems, and performance displays, capitalizing on its 15+ years of mass-production deployment history.[90] Volkswagen reported a 50% reduction in memory consumption for 5-inch screens in its California campervan using Qt in collaboration with Vector.[91] Similarly, Suzuki optimizes costs for electric vehicle digital cockpits, and Sauber enhances Formula 1 pit stop efficiency and safety.[90] The medical sector employs Qt for compliant, user-centric software in devices and imaging systems, adhering to standards like FDA and EU regulations. Fresenius Kabi integrates Qt for digital displays in infusion pumps and monitoring equipment, while Oncosoft achieved doubled development efficiency for real-time 3D medical imaging.[87] Dräger relies on Qt for ventilator and patient monitoring interfaces, with the framework powering solutions in 90% of top global MedTech firms due to its reliability in safety-critical environments.[92][93] In entertainment and consumer electronics, Qt supports media-rich applications and embedded systems. Panasonic Avionics deploys Qt in inflight entertainment platforms serving over 5 million passengers daily, enabling seamless cross-device experiences.[87] LG Electronics partners with Qt for in-vehicle entertainment platforms, extending to automotive infotainment adopted by multiple brands.[94] Additional industries include agriculture, where Argo Tractors cut development time by 40% for tractor controls.[87] Overall, Qt underpins deployments in over 70 industries, with adoption by firms like General Motors and Harman underscoring its versatility for high-stakes, multi-platform needs.[90][87]

Deployment in Desktop, Embedded, and Mobile

Qt enables deployment of applications across desktop operating systems such as Windows, macOS, and Linux, leveraging platform-specific integrations for native rendering and performance. Developers utilize Qt's build tools, including Qt Creator, to compile and package executables that adapt to each desktop environment via styles and platform plugins, minimizing the need for separate codebases.[95][5] In embedded systems, Qt supports resource-constrained hardware like ARM-based processors running Linux, with optimizations for low-memory footprints and direct framebuffer rendering when graphics acceleration is unavailable. This facilitates deployment in sectors including automotive dashboards, medical devices, and industrial IoT, where Qt's modular components allow stripping unnecessary features to reduce binary size.[96][97] For mobile platforms, Qt provides dedicated ports for Android and iOS, enabling a single C++ or QML codebase to generate native applications deployable via standard app stores. Android support includes integration with the Android NDK for JNI bridging, while iOS deployment uses Xcode for building and signing, with Qt handling cross-compilation through its toolchain.[98][5] This approach supports high-performance UIs on devices with varying screen sizes and input methods, though developers may need platform-specific adjustments for features like notifications or sensors.[99]

Market Position and Competitors

Qt holds a specialized market position as a mature cross-platform framework for native GUI development, particularly dominant in embedded systems, automotive infotainment, medical devices, and industrial applications where performance and reliability are paramount. In 2024, Qt Group achieved net sales of 209.1 million euros with an operating margin of 34.1%, underscoring its commercial strength amid a workforce of approximately 900 employees focused on enterprise licensing and support.[100][101] Its adoption spans sectors requiring low-latency UIs, such as defense and digital cockpits, but developer surveys indicate limited mainstream popularity compared to web-oriented tools, positioning Qt as a niche leader rather than a mass-market contender.[102][103] Key competitors include GTK, an open-source C-based toolkit prevalent in Linux desktop environments like GNOME, emphasizing native integration but lacking Qt's breadth in embedded and mobile support.[104] Electron, leveraging web technologies (HTML/CSS/JavaScript/Chromium), appeals to developers prioritizing rapid prototyping and ecosystem familiarity, though it incurs higher resource overhead—Electron claims a detectable but small cross-platform dev tools share around 1%, contrasting Qt's more targeted enterprise footprint.[105][106] Flutter, Google's Dart-based framework, rivals Qt in multi-platform (mobile/desktop/web) coverage with features like hot reload for faster iteration, gaining traction in consumer apps but criticized for higher embedded resource demands versus Qt's efficiency in constrained hardware.[107] Other alternatives encompass .NET MAUI for Microsoft-centric ecosystems, wxWidgets for lightweight native widgets, and Tauri for secure, web-rendered UIs with Rust backends—each carving niches where Qt's C++ heritage and licensing (dual open/commercial) provide differentiation, yet face erosion from free, modern rivals in web-mobile hybrids.[108][104]
FrameworkPrimary LanguageStrengths vs. QtWeaknesses vs. Qt
GTKC/GObjectNative Linux integration; fully free.Limited non-desktop support; steeper native binding curve.[104]
ElectronJavaScriptWeb dev accessibility; vast npm ecosystem.Bloat and performance hit on low-end devices.[106]
FlutterDartHot reload; pixel-perfect UIs across platforms.Less mature for embedded; higher footprint.[107]

Historical Development

Founding by Trolltech

Trolltech was founded on March 4, 1994, by Norwegian developers Haavard Nord and Eirik Chambe-Eng in Oslo to commercialize the Qt framework they had begun developing.[109] The duo conceived Qt in 1990 as students at the Norwegian University of Science and Technology in Trondheim, initially sketching its core ideas—such as a signal-slot mechanism for event handling—on a park bench to address limitations in existing GUI toolkits for Unix-like systems.[39] Development of the first code started in 1991, driven by their need for a portable C++ library to build cross-platform applications, beginning with support for X11 on Unix platforms.[110] The company's early focus was on Qt as a proprietary toolkit for creating graphical user interfaces, emphasizing portability across operating systems without source code modifications. Trolltech's initial team consisted primarily of Nord and Chambe-Eng, who handled core design and implementation, with Qt evolving from a personal project into a professional product marketed to developers seeking efficient widget-based applications.[111] On May 20, 1995, Trolltech publicly released Qt version 0.90 for X11/Linux under a custom free edition license that allowed non-commercial use with source access, marking the framework's debut and establishing Trolltech's role in the burgeoning software development market.[39] This release included foundational classes for windows, dialogs, and event processing, though it lacked full commercial licensing options until subsequent versions.[112] By 1996, Qt 1.0 introduced enhanced features like improved drawing primitives and database connectivity, solidifying its appeal for professional use while Trolltech expanded its operations with a small team dedicated to iterative improvements and platform ports.[113] The framework's design prioritized first-principles efficiency, such as meta-object compilation for runtime introspection, which distinguished it from competitors reliant on heavier runtime interpretations. Trolltech's strategy emphasized dual licensing—proprietary for commercial entities and free for open-source evaluation—to balance revenue and adoption, though this model later drew scrutiny over accessibility for free software projects.[4]

Acquisitions: Nokia and Beyond

In January 2008, Nokia Corporation announced its acquisition of Trolltech ASA, the Norwegian company that developed the Qt framework, for approximately $153 million in cash.[114] The deal, aimed at bolstering Nokia's cross-platform development capabilities for mobile and desktop applications, was completed on June 17, 2008, following regulatory approval.[115] Under Nokia's ownership, Qt was integrated into its software strategy, including support for Symbian and MeeGo platforms, with Nokia contributing to its open-source governance through the Qt Project hosted by the community.[115] By 2012, amid Nokia's strategic pivot away from certain software assets during its challenges in the smartphone market, the company sold its Qt technologies and business operations to Digia Oyj, a Finnish software firm, on August 9, 2012.[116] This transaction transferred Qt's product development, commercial licensing, and up to 125 employees primarily from Nokia's Oslo and Berlin teams to Digia, for a reported €4 million—substantially less than Nokia's original purchase price for Trolltech.[117] Digia had previously acquired Nokia's Qt commercial licensing and services business in March 2011, positioning it to consolidate full control over Qt's ecosystem.[118] Following the acquisition, Digia restructured Qt's operations, establishing The Qt Company as a dedicated subsidiary in September 2014 to focus exclusively on Qt's development, licensing, and community engagement.[119] In 2016, The Qt Company was separated from Digia through a demerger, forming Qt Group Plc as an independent publicly listed entity on the Nasdaq Helsinki exchange, with shares distributed to Digia shareholders.[120] This shift enabled Qt Group to pursue autonomous growth, emphasizing commercial licensing for embedded and automotive sectors while maintaining open-source contributions, without further major ownership changes through acquisition as of 2025.[121]

Shift to Open Source and Community Involvement

In January 2009, shortly after Nokia's acquisition of Trolltech in June 2008, Qt version 4.5 introduced licensing under the GNU Lesser General Public License (LGPL) version 2.1 alongside the existing GPL and commercial options.[122] This permitted proprietary software to dynamically link Qt libraries without triggering GPL copyleft obligations, addressing prior limitations that restricted closed-source usage and fostering wider adoption across open source and commercial domains.[42] The LGPL shift resolved longstanding community tensions, notably with projects like KDE that relied on Qt but faced licensing constraints for non-GPL applications, thereby encouraging greater contributions and integration in diverse ecosystems.[122] To formalize community governance, Nokia launched the Qt Project in October 2011, enabling collaborative development where individuals and organizations could participate in steering open source Qt evolution through merit-based contributions and modular repositories.[57] Digia's acquisition of Qt's commercial assets from Nokia in August 2012 included commitments to sustain the Qt Project, with explicit support for open source initiatives and symbiotic relationships with user communities such as KDE.[49] In 2014, Digia established The Qt Company as a dedicated entity, preserving the bifurcated model of community-led open source development under the Qt Project and company-driven commercial licensing and services.[123]

Key Milestones in Ownership and Strategy

Nokia completed its acquisition of Trolltech on June 17, 2008, for approximately €104 million, renaming the entity Qt Software and positioning Qt as a cornerstone for cross-platform development in its mobile operating systems, including Symbian and the short-lived MeeGo platform.[115][114] This strategic integration aimed to accelerate application portability amid Nokia's dominance in feature phones, though it later conflicted with the company's pivot to Windows Phone under a Microsoft partnership. As Nokia refocused amid declining market share, it divested Qt assets starting in March 2011, selling the commercial licensing and services business to Finnish firm Digia Plc to streamline operations.[124] On August 9, 2012, Nokia announced the sale of its remaining Qt software technology, intellectual property, and approximately 125 employees to Digia for €14 million (about $17 million), with the transaction closing on September 18, 2012.[116][124] Digia committed to sustaining Qt's dual-licensing model and open-source trajectory, forming the Qt Project governance body with community stakeholders to decentralize development oversight from corporate control. In September 2014, Digia restructured by spinning off its Qt operations into The Qt Company, a dedicated subsidiary to centralize commercialization, licensing, and R&D efforts, separating it from Digia's broader IT services portfolio.[112] The Qt Company pursued growth in enterprise sectors like automotive and embedded systems, culminating in its initial public offering on Nasdaq Helsinki in 2016, which provided capital for platform enhancements and global expansion while maintaining open-source commitments.[112] This shift emphasized sustainable revenue from professional licenses over volume mobile deployments, adapting to Qt's evolving role in IoT and industrial applications.

Criticisms and Limitations

Technical and Performance Issues

Qt applications have been reported to exhibit slower startup times and rendering performance compared to native platform UIs, with perceptible delays in loading and drawing elements.[125] This overhead arises from Qt's abstraction layers, which prioritize cross-platform consistency over platform-specific optimizations, leading to increased CPU and memory usage in graphics-intensive scenarios.[126] In Qt Quick and QML-based UIs, common bottlenecks include excessive JavaScript execution and unoptimized scene graph updates, which can degrade responsiveness and elevate resource consumption on lower-end hardware.[126] Binary sizes represent a longstanding limitation, with even minimal statically linked Qt applications exceeding 4 MB, or requiring distribution of up to 10 MB in dynamic libraries, contributing to bloat in embedded and mobile deployments.[127] This stems from Qt's comprehensive feature set, including redundant platform backends and extensive runtime dependencies, which complicate footprint reduction without custom builds or stripping. Developers have noted challenges in achieving native-like efficiency, particularly on ARM architectures where Qt's abstractions amplify performance gaps.[128] Threading introduces significant constraints, as Qt's GUI operations are inherently single-threaded and not thread-safe outside the main event loop, prohibiting direct manipulation of widgets, QML items, or rendering contexts from worker threads.[129] Attempts to integrate multithreading with OpenGL or hardware-accelerated rendering often result in context conflicts, freezes, or undefined behavior, especially on Linux where synchronization issues exacerbate delays.[130] Cross-platform rendering inconsistencies persist, such as misplaced controls and stylesheet bugs on macOS, alongside layout system complexities that hinder predictable behavior across Windows, Linux, and Apple ecosystems.[131] Specific modules like QMediaPlayer in Qt 6 have faced criticism for suboptimal performance on Linux and Windows, with frequent regressions during updates affecting playback smoothness and compatibility.[128] While Qt provides tools like QML Profiler for mitigation, these issues underscore the framework's trade-offs in abstraction versus low-level control, often requiring workarounds that increase development complexity.[132]

Developer Experience Challenges

Developers frequently report a steep learning curve with Qt, particularly for newcomers to C++ GUI frameworks, due to its extensive API and paradigms like signals and slots, which require understanding meta-object compiler (moc) processing and event-driven architecture.[133] This mechanism, while powerful for decoupling components, can obscure dependencies in large codebases, complicating debugging and maintenance as connections proliferate without explicit visibility in standard call graphs.[134] Overuse of signals and slots has been criticized for hiding control flow, making it harder to trace execution compared to direct function calls or virtual methods, with performance overhead in high-frequency scenarios exacerbating traceability issues.[135] Qt's documentation, while comprehensive for advanced users, often lacks beginner-friendly tutorials and examples, leading to frustration in initial onboarding; developers note that API references assume prior familiarity with Qt idioms, and searchability within the official docs can be inconsistent.[136] [137] Historical declines in documentation quality since Qt 4.4 have been attributed to shifts in maintenance priorities, though recent efforts aim to improve accessibility.[138] Integration challenges arise from Qt's custom containers and types (e.g., QString, QVariant), which pollute namespaces and hinder interoperability with standard C++ libraries or third-party debuggers lacking full Qt introspection support.[139] Build and tooling workflows present additional hurdles, including the transition from qmake to CMake, which demands reconfiguration for projects spanning Qt versions, and fragmented contribution processes involving multiple systems like Gerrit and Jira that impede community fixes.[140] Qt Creator, the integrated IDE, receives mixed feedback for its ergonomics, with pain points in dependency management, QML tooling, and cross-platform consistency, often requiring supplementary tools for complex embedded or mobile deployments.[140] Version upgrades frequently introduce breaking changes or deprecated APIs without seamless migration paths, as seen in iOS-specific adaptations or module reorganizations, amplifying refactoring efforts in long-lived projects.[141] Despite these, experienced teams mitigate issues through modular design and Qt's robust testing frameworks, underscoring that challenges are more pronounced in greenfield or resource-constrained settings.[142]

Business and Licensing Drawbacks

The dual licensing model of Qt requires proprietary software developers to either comply with LGPL terms—such as enabling dynamic linking, distributing modified Qt object code, and allowing users to replace the library—which can impose technical and legal complexities, or purchase a commercial license to bypass these restrictions.[143][144] Commercial licenses, mandatory for closed-source applications avoiding LGPL obligations, adopt a subscription structure without perpetual options, with pricing starting at $499 annually for startups under $100,000 revenue and five employees, but rising to $5,000 or more per developer per year for standard professional use.[145][146][54] In 2020, the Qt Company proposed limiting long-term support (LTS) releases exclusively to commercial licensees, sparking widespread community opposition that forced a reversal, as it threatened open-source users' access to stable versions and underscored revenue-driven decisions over ecosystem needs.[147] The shift to subscriptions in 2022, while simplifying some aspects like post-subscription distribution, has been criticized for fostering dependency and escalating costs over time, particularly for small firms or embedded projects where alternatives like fully permissive libraries avoid such burdens.[148][54] Commercial terms remain restrictive for certain use cases, such as networked applications, potentially requiring additional indemnification or limiting redistribution freedoms not present in open-source alternatives.[149] Business model critiques center on the Qt Company's emphasis on commercial revenue, which accounted for the majority of income but led to profitability challenges post-2015, prompting strategies perceived as prioritizing short-term sales over developer relations.[150] High sales pressure, including from commission-driven representatives urging unnecessary licenses despite LGPL viability, and rapid staff turnover have eroded trust among users, with some developers viewing the model as akin to Oracle's control over open-source projects.[151][152][140] For resource-constrained teams, these factors amplify total ownership costs beyond licensing, including compliance audits and potential migration risks if company policies shift further toward proprietary features.[153]

Community and Ecosystem Concerns

The Qt Project's governance structure has drawn criticism for granting disproportionate influence to The Qt Company, despite significant contributions from independent developers and organizations like KDE. In 2012, KDE articulated risks of fragmentation through forking and divergences between free and commercial Qt variants, emphasizing interdependence that could jeopardize open-source sustainability if corporate priorities prevail.[154] Historical data from 2013 illustrates this imbalance, with visualizations excluding Digia (The Qt Company's predecessor) revealing KDE and other community entities as primary code contributors during that period.[155] More recent analyses, including KDE community discussions, question why The Qt Company holds substantial decision-making power over a codebase largely shaped by external efforts, potentially stifling broader ecosystem input.[156] Licensing and support policies have exacerbated community apprehensions. In January 2016, Qt shifted its open-source licenses, retaining GPLv2, GPLv3, and LGPLv3 while discontinuing LGPLv2.1, ostensibly to enhance end-user freedoms by prohibiting proprietary runtime modifications under LGPLv3's anti-tivoization provisions.[47][157] This change, however, prompted concerns over reduced flexibility for legacy projects and heightened restrictions on commercial adaptations. Further tensions arose in 2020 over proposals for subscription-based access to long-term support (LTS) features, perceived as prioritizing revenue over open-source accessibility.[147] The impending end of Qt 5 community support on May 26, 2025—after which no free updates or security patches will be provided without paid extended services—poses risks to ecosystems dependent on stable, unmonetized versions, including legacy applications and distributions reluctant to migrate to Qt 6 due to compatibility breaks.[158] Development processes and tooling fragmentation hinder community participation. External observers have noted a disjointed infrastructure combining Jira for issues, Gerrit for reviews, mailing lists, and inaccessible internal documents, complicating contributions from non-company developers.[140] While The Qt Company reported that external contributors accounted for 17% of commits in 2024, signaling some community involvement, critics argue this underscores reliance on corporate resources amid governance opacity, potentially deterring broader adoption and forking safeguards.[58] KDE's heavy investment in Qt, underpinning Plasma and frameworks, amplifies these ecosystem vulnerabilities, with discussions questioning whether Qt's corporate stewardship impedes wider desktop environment proliferation.[159]

References

  1. Development Framework for Cross-platform Applications - Qt
  2. Get and Install Qt | Qt 6.10
  3. From QtWidgets to Qt6 and Beyond: What Is Qt Capable Of? - Extenly
  4. History of Qt Software - André Machado | Blog - Substack
  5. Embedded Software Development Tools & Cross Platform IDE - Qt
  6. Qt Features, Framework Essentials, Modules, Tools & Add-Ons
  7. Qt Licensing | Choose the Right License for Your Development Needs
  8. Qt for Open Source Development
  9. The Qt framework - Viking Software A/S
  10. Qt | Tools for Each Stage of Software Development Lifecycle
  11. Signals & Slots | Qt Core | Qt 6.10.0
  12. Qt, QML, Widgets…What Is The Difference? - Qt for Python
  13. Qt Creator Documentation
  14. Qt Multimedia | Qt 6.10.0
  15. Supported Platforms & Languages for Software Development - Qt
  16. For developers | Cross-platform development - Qt
  17. All Modules | Qt 6.10 - Qt Documentation
  18. All Classes by Module | Qt 6.10
  19. [PDF] Using Qt for non-graphical applications - Fosdem
  20. using Qt in non GUI application, pros and cons? - c++ - Stack Overflow
  21. QEventLoop Class | Qt Core | Qt 6.10.0
  22. QObject Class | Qt Core | Qt 6.10.0
  23. The Meta-Object System | Qt Core | Qt 6.10.0
  24. Model/View Programming | Qt Widgets | Qt 6.10.0
  25. QML Syntax Basics - Qt Documentation
  26. Important Concepts In Qt Quick - Convenience Types
  27. Qt Core | Qt 6.10.0
  28. Additional Modules | Qt 6.10 - Qt Documentation
  29. Obligations of the GPL and LGPL - Qt
  30. Using Qt 6 under LGPLv3 - Burkhard Stubert
  31. Supported Platforms | Qt 6.10 - Qt Documentation
  32. Qt Design Studio - UI Development Tool for Applications & Devices
  33. Development Tools | Qt 6.10 - Qt Documentation
  34. Select the build system | Qt Creator Documentation
  35. How to use CMake with Qt | KDAB
  36. Resource Compiler (rcc) | Qt 6.10 - Qt Documentation
  37. Building | Qt VS Tools Manual
  38. Qt Quick Tools and Utilities - Qt Documentation
  39. Qt History - Qt Wiki
  40. Qt version history - Qt Wiki
  41. Nokia adopts LGPL for Qt popularity - The Register
  42. Qt goes LGPL - Bootlin
  43. Nokia and Digia working together to grow the Qt community
  44. Nokia sells Qt commercial licensing and services business to Digia
  45. Qt Licensing | Qt 6.10
  46. Qt FAQ | Qt Open Source Licensing
  47. Qt open source licensing changed and product structure updated to ...
  48. https://www.qt.io/licensing
  49. Digia Committed to Thriving Qt Ecosystem - KDE.news
  50. DIGIA HAS SIGNED AN AGREEMENT TO ACQUIRE Qt SOFTWARE ...
  51. Qt offering changes 2020
  52. Qt Could Go Proprietary, KDE Relationship And Qt-Based Free ...
  53. [PDF] Protecting against proprietary re-licensing with a community contract
  54. Qt rethinks commercial licensing, so you can distribute apps after ...
  55. The Qt Governance Model - Qt Wiki
  56. The Qt Project
  57. KDE Free Qt Foundation
  58. Top Contributors of 2024 - Qt
  59. the-qt-story
  60. Introduction to Qt | Object Computing, Inc.
  61. Qt | Encyclopedia MDPI
  62. Qt framework celebrates its 20th anniversary - SD Times
  63. Porting to Qt 4 - GitHub Pages
  64. How different is Qt4 from Qt3? - c++ - Stack Overflow
  65. Thoughts about Qt 5
  66. Porting from Qt 4 to Qt 5 - KDAB
  67. 1. Meet Qt 5 — Qt5 Cadaques Book vmaster
  68. [PDF] Migrating from Qt 4 to Qt 5
  69. What's New in Qt 5 | Qt| Felgo Documentation
  70. Qt 6.0 Officially Released - Phoronix
  71. Porting to Qt 6 | Qt 6.10 - Qt Documentation
  72. Qt 6 Improves QML, Adopts C++17, and More - InfoQ
  73. Qt 5 to Qt 6 migration– a step-by-step tutorial - Spyrosoft
  74. Why update from Qt5 to Qt6 - ekke's apps | Qt 6 - WordPress.com
  75. What's New in Qt 6.8 - Qt Documentation
  76. Qt 6.9 Released
  77. Qt 6.10 Released!
  78. Qt 6.8 LTS Released!
  79. Qt for Python release: 6.10 is here!
  80. Qt Releases | Qt 6.10
  81. Qt | endoflife.date
  82. Any famous apps built using QML ? : r/QtFramework - Reddit
  83. telegramdesktop/tdesktop: Telegram Desktop messaging app - GitHub
  84. Telegram Applications
  85. Debian -- Details of package virtualbox-qt in sid
  86. Maya Help | Working with Qt - Autodesk product documentation
  87. Qt Success Stories | Real-World Applications & Innovations
  88. What are some examples of applications created with QT? - Quora
  89. Using Qt: 10 Famous and Successful Cases - Hackernoon
  90. Automotive HMI Development for Software-Defined Vehicles - Qt
  91. https://www.qt.io/volkswagen-built-with-qt
  92. Qt Framework and its Hidden Gems for Medical Software
  93. [PDF] Safe and Effective Medical Device Development with Qt
  94. Qt Group and LG Electronics partner for in-vehicle entertainment
  95. Cross-Platform Desktop Application Development - Qt
  96. Accelerate Embedded Software Development with Qt Tools
  97. C++ and Qt for embedded systems - Integra Sources
  98. Multiplatform Mobile App Development - Qt
  99. What Is Qt framework, Why to Use It, and How? - Lemberg Solutions
  100. [PDF] Annual Report 2024 - Qt
  101. Financials - Qt
  102. https://www.statista.com/statistics/793840/worldwide-developer-survey-most-used-frameworks/
  103. Technology | 2024 Stack Overflow Developer Survey
  104. 12 Great Qt Alternatives: Top Similar Software in 2025 - AlternativeTo
  105. Electron Vs Qt for Application Development : In-Depth Comparison
  106. Electron.js vs Qt: Which Is Best for Modern UI Development?
  107. QT vs. Flutter: Which framework is better for embedded systems?
  108. Best frameworks for cross-platform desktop app development
  109. Trolltech - Crunchbase Company Profile & Funding
  110. aKademy Interview: Eirik Chambe-Eng of Trolltech - KDE.news
  111. Painful Lessons From Scaling a Software Company | by Haavard Nord
  112. About The Qt Group - Code Less & Create More
  113. Company Information - Blackjack
  114. Nokia Acquires Trolltech For $153 Million - TechCrunch
  115. Nokia completes Trolltech acquisition
  116. Nokia sells Qt software business to Finland's Digia | Reuters
  117. The Nokia Asset Offload Continues: Qt Assets Go To Digia For ...
  118. Nokia sells Qt cross-platform software framework to Digia
  119. The Qt Company - Qt Group Oyj - Andreas's Hansen Newsletter
  120. https://dcfmodeling.com/blogs/history/0rg5l-history-mission-ownership
  121. MAJOR SHAREHOLDERS OF QT GROUP PLC
  122. Nokia Qt LGPL switch huge win for cross-platform development
  123. Digia gives Qt its own company - SD Times
  124. Nokia completes sale of Qt software business to Digia
  125. Smoothness and performance of Qt based systems vs. native apps ...
  126. Qt Quick / QML performance optimisation dos and dont's - Spyrosoft
  127. Thread: qt weak points and disadvantages? - Qt Centre Forum
  128. QMediaplayer 6 bad performance - Qt Forum
  129. The Eight Rules of Multithreaded Qt - KDAB
  130. Qt Threading Issues in Linux - Stack Overflow
  131. Trying Qt. Seems great. What downsides am I missing? : r/cpp - Reddit
  132. Qt Performance and Tools Update Part 1
  133. Why isn't qt so popular - Qt Forum
  134. Is it a good practice to use signals and slots in Qt also when no input ...
  135. Qt signal is ten times slower than a virtual function | Hacker News
  136. The problem with Qt (my opinion) : r/QtFramework - Reddit
  137. Difficulty in understanding the Qt documentation - Stack Overflow
  138. Improving the Qt documentation - Qt Centre Forum
  139. What's your opinion of the Qt framework? : r/cpp - Reddit
  140. Current Issues With The Qt Project - From The Outside Looking In
  141. Qt for iOS – Tips, Insights and Biggest Painpoints - Somco Software
  142. Is Qt Right for Your Project? - Factors to Consider When Choosing a ...
  143. Is it difficult for commercial software to comply with Qt's LGPL license ...
  144. QT Licensing - limitations - Open Source Stack Exchange
  145. $499 for small companies and startups. QT is finally understanding ...
  146. Why is QT so expensive? 5000+ dollar a year - Qt Forum
  147. What is the controversy that is going on with Qt? : r/kde - Reddit
  148. Qt commercial licensing simplified!
  149. Current issues with the Qt project from the outside looking in
  150. Qt company, don't speak for developers anymore, your ... - Qt Forum
  151. Qt Commercial Pricing is a Joke : r/QtFramework - Reddit
  152. QT licensing query - Technical Support - Toradex Community
  153. Do Not Sign the Qt License Agreement Unchanged
  154. KDE Issues Statement Regarding Future Use Of Qt - Phoronix
  155. Sadly, I fear Digia (and its owned spin-off, the Qt Company) will be ...
  156. Why do we give so much power to the Qt Company when they don't ...
  157. Qt tightens open-source licenses - Tech Design Forum
  158. Qt 5 Support Is Ending – What You Need to Know - Slint
  159. Is Qt holding KDE back? - General
User Avatar
No comments yet.