QML Live is a local and remote Qt Quick live reloading system. It allows you to change your QML user interface source code and view the result in realtime. Often in User Interface (UI) development you need to edit the placement or animations to provide the user experience the design team envisions. This process of trial and error is tedious with the classic edit-save-run-exit cycle. QML Live makes this cycle more effective: whenever a file changes, the scene reloads automatically.

QML Live Bench is the all inclusive QML live reloading tool, that allows you to select a workspace to watch over and provides a Prime QML Live Runtime for the selected QML document. The “Prime QML Live Runtime” is a special type of Runtime that follows the currently selected .qml file. In contrast, QML Live Bench lets you preview several files simultaneously.

Read more: https://doc.qt.io/QMLLive/index.html

Installation guide: https://doc.qt.io/QMLLive/qmllive-installation.html

GammaRay is an introspection tool for Qt applications developed by KDAB. Leveraging the QObject introspection mechanism it allows you to observe and manipulate your application at runtime. This works both locally on your workstation and remotely on an embedded target.

Augmenting your instruction-level debugger, GammaRay allows you to work on a much higher level, with the same concepts as the frameworks you use. This is especially useful for the more complex Qt frameworks such as model/view, state machines, or scene graphs.

When trying to analyze bugs in your application, a instruction-level debugger is usually your first tool of choice, and rightfully so. Debuggers allow you to follow the program flow and allow you to inspect the state of objects or variables. When using a debugger with proper Qt integration, such as in QtCreator, it will also handle Qt’s own data types correctly. However, when dealing with complex frameworks this level of detail is often too low-level. Keeping an overview in a large scene graph or following the complex interactions between models and views can quickly become a cumbersome task.

GammaRay addresses this by providing domain-specific debugging aids on a much higher level. It provides easy ways of navigating through the complex internal structures you find in some Qt frameworks, such as the QtQuick scene graphs, model/view, QTextDocument, state machines, and more. Unlike the debugger, GammaRay understands those internal structures and can present them in a meaningful way.

GammaRay is available for all major platforms and can inspect applications right from the start or attach to an already running one. It also supports remote debugging, which is especially valuable when working on embedded systems.

Read more: https://doc.qt.io/QMLLive/index.html

The emulator enables you to test and debug applications in an environment practically identical to that of the device, without having to own a device and connect it to the development host. If memory that is allocated in applications is not freed, a memory leak occurs. To catch memory leaks, use dynamic analysis tools, such as Valgrind tools on applications running on devices.

Read mode: User manual for Emulator

Qt Creator provides a cross-platform, complete integrated development environment (IDE) for application developers to create applications for multiple desktop, embedded, and mobile device platforms, such as Android and iOS. It is available for Linux, macOS and Windows operating systems. For more information, see Supported Platforms.

In addition, you can use the experimental WebAssembly plugin to build applications in web format and run them in web browsers.

Read mode: Qt Creator Manual

Qt provides excellent support for translating Qt C++ and Qt Quick applications into local languages. Release managers, translators, and developers can use Qt tools to accomplish their tasks.

Release managers bear the overall responsibility for the release of the application. Typically, they coordinate the work of developers and translators. They can use the lupdate tool to synchronize source code and translations and the lrelease tool to create run-time translation files for use by the released application.

Translators can use the Qt Linguist tool to translate text in applications. No computer knowledge beyond the ability to start a program and use a text editor or word processor is required.

Разработчики must create Qt applications that are able to use translated text. They should also help translators identify the context in which phrases appear. Developers can use tutorials to learn about their tasks.

Read mode: User manual Qt Linguist

The qmake tool helps simplify the build process for development projects across different platforms. It automates the generation of Makefiles so that only a few lines of information are needed to create each Makefile. You can use qmake for any software project, whether it is written with Qt or not.

qmake generates a Makefile based on the information in a project file. Project files are created by the developer, and are usually simple, but more sophisticated project files can be created for complex projects.

qmake contains additional features to support development with Qt, automatically including build rules for moc and uic.

qmake can also generate projects for Microsoft Visual studio without requiring the developer to change the project file.

Read more: qmake user manual

makeqpf is a tool to generate pre-rendered fonts in QPF2 format for use on Embedded Linux.

The Meta-Object Compiler, moc, is the program that handles Qt’s C++ extensions.

The moc tool reads a C++ header file. If it finds one or more class declarations that contain the Q_OBJECT macro, it produces a C++ source file containing the meta-object code for those classes. Among other things, meta-object code is required for the signals and slots mechanism, the run-time type information, and the dynamic property system.

The C++ source file generated by moc must be compiled and linked with the implementation of the class.

If you use qmake to create your makefiles, build rules will be included that call the moc when required, so you will not need to use the moc directly. For more background information on moc, see Why Does Qt Use Moc for Signals and Slots?

Read more: https://doc.qt.io/qt-5/moc.html

Read more: https://doc.qt.io/qt-5/uic.html

The rcc tool is used to embed resources into a Qt application during the build process. It works by generating a C++ source file containing data specified in a Qt resource (.qrc) file.

Read more: https://doc.qt.io/qt-5/rcc.html

The Qt D-Bus XML compiler is a tool that can be used to parse interface descriptions and produce static code representing those interfaces, which can then be used to make calls to remote objects or implement said interfaces.

qdbusxml2cpp has two modes of operation, that correspond to the two possible outputs it can produce: the interface (proxy) class or the adaptor class. The latter consists of both a C++ header and a source file, which are meant to be edited and adapted to your needs.

The qdbusxml2cpp tool is not meant to be run every time you compile your application. Instead, it’s meant to be used when developing the code or when the interface changes.

The adaptor classes generated by qdbusxml2cpp are just a skeleton that must be completed. It generates, by default, calls to slots with the same name on the object the adaptor is attached to. However, you may modify those slots or the property accessor functions to suit your needs.

The Qt D-Bus Viewer is a tool that lets you introspect D-Bus objects and messages. You can choose between the system bus and the session bus. Click on any service on the list on the left side to see all the exported objects.

You can invoke methods by double-clicking on them. If a method takes one or more IN parameters, a property editor opens.

Right-click on a signal to connect to it. All emitted signals including their parameters are output in the message view on the lower side of the window.

The Qt Quick Compiler is a development add-on for Qt Quick applications which allows you to compile QML source code into the final binary. When you use this add-on, the application’s startup time is significantly improved and you no longer need to deploy .qml files together with the application.

Qt Quick enables rapid development cycles for your applications. This is accomplished by doing away with the traditional C++ compilation step. Instead, we load the .qml source code on demand at run-time. The popular Just-in-time (JIT) compilation technique is used to generate machine code on the fly, which speeds up the execution of JavaScript and QML binding expressions.

Read more: https://doc.qt.io/archives/QtQuickCompiler/

Qt VS Tools integrate the Qt development tools into Microsoft Visual Studio 2015, and later. This enables developers to use the standard Windows development environment without having to worry about Qt-related build steps or tools. You can install and update Qt VS Tools directly from Microsoft Visual Studio.

The main features of Qt VS Tools are:

• Wizards for creating new Qt projects and classes.
• Automated build setup for the Meta-Object Compiler (moc), User Interface Compiler (uic), and Resource Compiler (rcc).
• Import and export of Qt project files (.pro) and project include files (.pri).
• Automated conversion of a Qt VS Tools project to a qmake project, or the other way around.
• Integrated Qt resource management.
• Creating a Qt translation source (TS) file and starting Qt Linguist to translate the strings.
• Starting Qt Designer to design widget-based UIs for applications.
• Integrated Qt documentation.
• Debugging extensions for Qt data types.

If the user interface of an application has a lot of text, it may cause a small, but noticeable, performance impact the first time it is displayed to the user. This is especially true if the text is rendered in multiple different fonts or use a large amount of distinct characters (common for instance in writing systems such as Hanzi, written Chinese).

The reason is that in order to render the text efficiently later, Qt will spend some time creating graphical assets for each of the glyphs that will later be reused. This happens the first time a glyph is displayed in the scene.

For advanced users who want to optimize startup performance, it is possible to pregenerate this font cache, as long as Text.QtRendering is the rendering type in use. The Qt Distance Field Generator tool can be used to pregenerate the cache, either for all glyphs in the fonts, or just a selection that are known to be displayed during a critical phase.

Note: This is a tool that may be used by advanced users to streamline their application in ways that cannot be done automatically by Qt. For most common use cases, the default behavior in Qt will be sufficient.

Read more: https://doc.qt.io/qt-5/qtdistancefieldgenerator-index.html

The Qt Installer Framework provides a set of tools and utilities to create installers for the supported desktop Qt platforms: Linux, Microsoft Windows, and macOS.

Read mode: https://doc.qt.io/qtinstallerframework/index.html

Qbs is a tool that helps simplify the build process for developing projects across multiple platforms. Qbs can be used for any software project, regardless of programming language, toolkit, or libraries used.

Read more: Qbs manual

Qt Assistant is a tool for viewing on-line documentation in Qt help file format. For more information about basic Qt Assistant functions, see Qt Assistant Quick Guide.

Qt installations include a set of reference and tools documentation that you can view in the Qt Creator IDE and in Qt Assistant. You can add custom documentation to the set of documents displayed in the Qt Assistant main view. For detailed information about all Qt Assistant functions, see Using Qt Assistant.

You can use Qt Assistant as the help viewer in your applications. You can display your own documentation and customize Qt Assistant to look and feel like part of your application. You can change the window title or icon, as well as menu texts and actions. For more information, see Customizing Qt Assistant.

Read more: https://doc.qt.io/qt-5/qtassistant-index.html

Qt Configuration Tool is a GUI application for the Qt feature system introduced with Qt 5.8. Qt Configuration Tool is part of the Qt Lite concept that provides features and tools for creating and building smaller Qt binaries. To use the tool, you must have a commercial Qt license.

With Qt Configuration Tool, you can select features, modules, and configure options that are included in the Qt build configuration. Qt Configuration Tool automatically takes care of dependencies between them.

Creating New Qt Build Configuration describes how you create a new Qt build configuration with Qt Configuration Tool. Modifying Qt Build Configuration describes how you can use Qt Configuration Tool to select modules and features that are already included in the Qt build configuration.

Using Tool with Yocto Builds describes how to use Qt Configuration Tool with the Yocto builds.

Read more: https://doc.qt.io/QtForDeviceCreation/qt-configuration-tool.html

After you have flashed the Boot to Qt software stack to your target device, you can deploy all kinds of Qt applications into your device via Qt Creator. Deploying is done when you run the application. See Tutorial: Deploying Your First Project with Boot to Qt for detailed steps that are related to deploying applications via Qt Creator.

The following sections provide general information about deploying with the Boot to Qt software stack:

• Target Path of Deployed Application describes the modifications required in the .pro file.
• Deploying Application Resources describes how you deploy QML files, images, and other resources to the target device.
• Custom Deployment Steps instructs how you can customize the deployment steps in Qt Creator.

Read more: https://doc.qt.io/QtForDeviceCreation/b2qt-deploying-b2qt.html

froglogic Squish GUI Tester is the tool of choice for several thousand companies worldwide to automate the functional regression and system tests of their graphical user interfaces and Human Machine Interfaces.

The link to the site1: https://kb.froglogic.com/

froglogic Coco. A key indicator to measure the quality of testing is to understand how much of your application’s source code is covered by the tests at hand.

The link to the site1: https://kb.froglogic.com/

froglogic Test Center is a central, lightweight test result management platform connection test automation with the entire development process.

The link to the platform: https://www.froglogic.com/testcenter/