Felgo Hot Reload empowers you to make instant QML and JS code changes and resource updates without recompilation or redeployment; it applies these changes without losing the state of your running application. If you are currently working on a sub-screen, you will not have to navigate to it again after every change, and you will stay exactly where you are in your application.

Felgo Hot Reload consists of two components:

Felgo Hot Reload GUI application and
Felgo Hot Reload library.

1.1. Felgo Hot Reload GUI Application

The Felgo Hot Reload GUI application (FelgoHotReload.exe on Windows or FelgoHotReload on other platforms) listens for project file changes and sends those changes to the running application. It is located in the root folder of the installation directory.

1.2. Felgo Hot Reload Library

The Felgo Hot Reload library. It gets linked into your application binary during the development workflow (not linked to the release version). You can integrate the library via qmake, CMake, or MSBuild build system helpers. You can find the library in the client subfolder of the installation directory.

2. Installation

You can install Felgo Hot Reload using the specific installer for your development platform:

After downloading and starting the installer, you are asked to select:

The installation folder

The Qt versions for which to install the Felgo Hot Reload library. You can select as many versions as you need. The Felgo Hot Reload GUI Application will be installed by default.

Windows only: Start Menu Shortcuts

After the installation, you can start configuring your project to use Felgo Hot Reload.

3. Preparation and Setup

3.1. License Key

Before starting work, you need to provide a license key that you have received from Felgo as a part of an order.

Open the Felgo Hot Reload GUI application. First, it will ask you to enter the license key. Enter the received license key and press “Continue”.

If the given license key is valid, it will ask you to select a project directory. This step is necessary only once.

You can trial Felgo Hot Reload without placing an order. First, select “Demo mode” when you are asked to provide the license key. After selecting this option, the application will ask you to select a project directory. After choosing the directory, you will see a message that the license key is not set, and the application will be in demo mode. This mode allows you to use Felgo Hot Reload with a reduced set of features:

Support only desktop applications
Felgo Hot Reload shows an overlay on top of your application UI
Your application will automatically disconnect after a limited time.

To set the license key, open the settings window from the banner or via the “Settings” button in the bottom left corner.

Locate the text field “License Key” at the very top of the screen.

Paste the received license key, and press “Save”.

When you successfully add a license, the License Banner will disappear. You will see information about your current license in the Felgo Hot Reload settings.

Note: If you have any questions about obtaining or using a license key, please contact support@felgo.com.

3.2. Initial Project Configuration

Adding Felgo Hot Reload to your project involves two steps: First, add the FelgoHotReload library to your project on linker level, and second, instantiate Felgo Hot Reload in your project source code.

This section gives step-by-step instructions on integrating Felgo Hot Reload into a project. You can check the FelgoHotReloadDemo project to see all the changes required for Felgo Hot Reload integration.

Note: On first start, an integration wizard is shown in the GUI application. It provides instructions and code snippets to add Felgo Hot Reload to your project. You can read more details about the recommendations in the sections below.

3.2.1. Add Hot Reload to your project

Here, we cover the most common build systems: CMake, qmake (Qt 5.15), and MSBuild (Windows Visual Studio).

CMake

Apply the following changes to configure your CMake-based project with Felgo Hot Reload:

Add the FelgoHotReload CMake package in CMakeLists.txt (adapt to match your installed Felgo Hot Reload client path, the Qt version, and the compiler in use):

# Felgo Hot Reload for host builds
set(FelgoHotReload_DIR "${FELGO_HOT_RELOAD_PATH}/client/${QT_VERSION}/${COMPILER}/lib/cmake/FelgoHotReload" CACHE PATH "FelgoHotReload directory" FORCE)

# Felgo Hot Reload for cross-compiling

# list(APPEND CMAKE_FIND_ROOT_PATH "../client/${QT_VERSION}/gcc_64")

find_package(FelgoHotReload CONFIG REQUIRED)

# Link Felgo Hot Reload

felgohotreload_configure_executable(${CURRENT_PROJECT_NAME})

Notes:

If using multiple modules, the find_package(FelgoHotReload CONFIG REQUIRED) needs to be in the root CMakeLists.txt, since it calls a deferred function that automatically detects all the modules required for the Hot Reload configuration.
Make sure to call felgohotreload_configure_executable(target) before qt_finalize_target(target) when adding Felgo Hot Reload to a Qt 6 Android project using CMake.

qmake

Note: qmake support is only maintained for Qt 5.15.

Apply the following changes to configure your qmake-based project with Felgo Hot Reload:

Include and link FelgoHotReload in the qmake .pro file (adapt to match your installed Felgo Hot Reload client path, Qt version, and the compiler in use):

# Add Felgo Hot Reload

include("$${FELGO_HOT_RELOAD_PATH}/client/$${QT_VERSION}/$${COMPILER}/qmake/FelgoHotReload.pri")

MSBuild

You can add property sheets to your Qt projects in Visual Studio.

In Visual Studio, open the Property Manager view, right-click on Debug, and select Add Existing Property Sheet…
Select the FelgoHotReload_Debug.props file:

Note: Follow those steps for the Release build with the file FelgoHotReload_Release.props if you want to use Hot Reload with your release build.

Note: You can also add a new configuration named Debug HotReload (or similar) to switch between a Debug version with and without Hot Reload enabled from the configuration menu.

3.2.2. Load Hot Reload instead of your main QML file

Typically, you only include Felgo Hot Reload in the application's debug build. This approach allows for a debug build with Felgo Hot Reload for development and testing while maintaining a separate release build for distribution.

It's advisable to have a method to quickly toggle Felgo Hot Reload on and off. When you incorporate Felgo Hot Reload into a project, it automatically defines the USE_FELGO_HOT_RELOAD symbol. This symbol can be utilized in your C++ code to write Felgo Hot Reload-specific instructions.

The following steps are required to load the Felgo Hot Reload instead of the main QML file in your application logic:

Include the Felgo Hot Reload header file:

#include <FelgoHotReload>

Comment out the loading of the main QML file:

// qmlEngine.load(mainQmlFile);

Load FelgoHotReload instead, e.g., with static initialization:

static FelgoHotReload felgoHotReload(&qmlEngine);

Note: The Demo Project illustrates how to implement this using the conditional USE_FELGO_HOT_RELOAD symbol.

3.2.3 Update C++ initialization code

Making the changes above will delay loading the QML file until you’ve connected your application to the Felgo Hot Reload GUI application. Because of this, any calls to QQmlApplicationEngine::rootObjects() will return an empty list. If you need to do some initialization steps that rely on these objects, we recommend using a handler for the QQmlApplicationEngine::objectCreated() signal. Move your initialization code into the handler to ensure the object you require is created.

For example, the following code:

qmlEngine.load(mainQmlFile);

initializeApplication(qmlEngine.rootObjects().first());

is updated to:

//qmlEngine.load(mainQmlFile);

QObject::connect(&qmlEngine, &QQmlApplicationEngine::objectCreated, [&](QObject *object, const QUrl &url) {

// You should check that the object is the one you are expecting

initializeApplication(object);

});

static FelgoHotReload felgoHotReload(&qmlEngine);

3.3. Hot Reload Configuration File

Felgo Hot Reload needs information about your project structure. It will watch specified files for changes and apply them to the running application. The information is stored inside a configuration file named hot_reload_config.json.

Felgo Hot Reload searches for this file inside your project's root directory. If the configuration file does not exist, it will be created and filled with minimal information that the Felgo Hot Reload GUI application automatically detects.

3.3.1 Auto-detecting configuration

Integrating the Felgo Hot Reload Client libraries generates an additional configuration file during the CMake process. All detected information is saved in the felgo_hot_reload_cmake_targets_info.json file. This file is located next to your project’s root CMakeLists.txt file.

This temporary file allows Felgo Hot Reload to detect changes made to your project and add them to the Hot Reload configuration (e.g., building the application for a different Qt version).

Requirements:

CMake version 3.19 or greater
Qt 6.3.0 or higher

When used with older Qt versions, information about QML targets (modules) will not be automatically detected.

The following information is parsed and collected from CMake:

Information about the compiler and the Qt version used
The file that contains the main function
Build directory
The main QML file. Files with Window-derived root components are considered for this.
Information about your Qt resources (.qrc files)
Information about folders containing .qml and .js files
If using Qt version >= 6.3.0:

Information about QML targets (modules): Target name, URI, version, QML files, and resources in the target

3.3.2 Configuration Editor

If you are using a Qt version before 6.3 or the automatic configuration needs adjustments, manual configuration might be required.

This can be done inside the Felgo Hot Reload GUI application configuration editor.
To access this, click on the configuration button in the bottom right part of the Felgo Hot Reload GUI app:

In the configuration page, you can see information about the project, qml modules, and resources. In the example image below, you can see the configuration used by the Demo Project.

The following sections provide details about the file contents:

Project directory

This is the directory the GUI application was opened with. This cannot be changed in the configuration editor.

To its right, there is the “Clear config” button. It allows you to clear the current configuration and run the auto-detection algorithm again.

Project file

The current project file. You can modify this if the detected project file is different from the root project file.

Main QML file

This is the first QML file loaded by your application. It is the parameter of the QQmlEngine::load, QQmlEngine::loadFromModule, or QQuickView constructor call.

The auto-detect feature scans the qml files and looks for one that could be the main qml file. In some cases where projects use QQuickView the main qml file might be incorrectly detected if the file is not named Main.qml

Project specifics can affect how this file is detected. Make sure the correct file was detected for your project.

Qt version and compiler

Acts as a filter to display the configurations used by the QML modules and resources (see below).

Felgo Hot Reload always prioritizes a specific configuration over a general one. For example, if a module is configured for “All” Qt versions and compilers, and another for 6.8.3 and msvc2022_64, it will always prioritize the specific configuration when a client using the same Qt version and compiler connects. Otherwise, it will default to the generic configuration.

QML modules

Felgo Hot Reload can reload files that have a correct configuration added to Qt modules or resources.

For the modules, the following information is necessary:

The source directory, which contains the QML files used by a module. These files are monitored for changes, and the connected clients are notified whenever a change is made.
The qmldir file. This file can be found inside the build directory after the project is built.

The module URI is read from the qmldir file. It cannot be changed manually.

To add a new module, press the “+” icon in the upper-right corner of the section.

This will prompt two selection dialogs where you have to select the following:

The source directory where the actual QML files are monitored for changes
The qmldir file, which can be found inside the build folder

This will add a new module with the currently selected Qt version and compiler. If “All” is selected in any of these, the new module will be a general one. If you want a specific Qt version or compiler, select it before pressing the “+” button.

You can remove a module by pressing the “X” button next to the module title. This marks the module for removal. You can make this change permanent when saving the configuration, or revert it by pressing the same button again.

QML resources and directories

Felgo Hot Reload can reload files outside Qt modules and plugins. In this case, you have to specify the path to the source directory or to a qrc resource.

You add a qrc file to the resources with the following steps:

Press the left “+” which has “qrc” specified
Select the qrc file you want to monitor for hot-reloading in the dialog that pops up

To add a normal directory to Hot Reload:

Press the left “+” which has “dir” specified
Select the directory you want to monitor for hot-reloading in the dialog that pops up
Optionally, you can set a resource prefix for the files in the selected directory

Expand the newly added directory entry
Fill the “Resource prefix” section for the configuration

Information about loading module and plugin binaries

Felgo Hot Reload creates a local copy of the configured module and plugin libraries. Copying can be unnecessarily time-consuming when running the application locally on your development machine. You can override the behavior with the “Use local plugins” checkbox at the end of the configuration page:

If it's set to true, Felgo Hot Reload will not create the local copy of the libraries. It will use the libraries at the paths in the qml_plugin_paths array.
If set to false, Felgo Hot Reload will make a local copy of the libraries.

Updating configuration file automatically

You can choose whether the hot_reload_config.json file is updated automatically.

Automatic configuration detection is enabled for all the projects by default.
Projects previously configured with a version older than 1.6.0 that already contain a hot_reload_config.json will not receive automatic configuration updates and must be manually toggled.

3.3.3. Advanced configuration topics

Disabling automatic config detection

You can turn off automatic configuration detection by passing the --disableAutoConfig command line argument to the Hot Reload GUI Application at start-up. This way, the toggle from the configuration page will be ignored entirely.

Forcing automatic config detection

You can force automatic configuration detection even with an older hot_reload_config.json. Pass the --forceAutoConfig command line argument to the Hot Reload GUI Application at start-up. This way the toggle from the configuration page will be ignored entirely.

Manually editing the configuration file

As an example, a project defining three modules with URIs DemoStaticPlugin , Demo.SharedPlugin and demo.qml.module will have a configuration JSON similar to this:

{

"main_qml_file": "qml/main.qml",

"qml_module_paths":[

"qml",

{

"path": "qml_static_plugin",

"target_path": "DemoStaticPlugin"

{

"path": "qml_shared_plugin",

"target_path": "Demo/SharedPlugin"

{

"path": "qml_module",

"target_path": "demo/qml/module/qml_module"

}

"qml_plugin_paths":[

{

"path": "build/MSVC2019_64bit-Debug/DemoStaticPlugin",

"target_path": "DemoStaticPlugin"

{

"path": "build/MSVC2019_64bit-Debug/Demo/SharedPlugin",

"target_path": "Demo/SharedPlugin"

{

"path": "build/MSVC2019_64bit-Debug/demo/qml/module",

"target_path": "demo/qml/module"

}

"use_local_plugins": true

}

Note: You can build the Demo Project repository to obtain a sample JSON configuration file. You may copy it and adapt it to your project.

The following sections provide details about the file contents.

Root QML file

This is the first QML file loaded by your application. It is the parameter of the QQmlEngine::load, QQmlEngine::loadFromModule, or QQuickView constructor call. The path must be relative to the configuration JSON and added to the main_qml_file JSON key.

It will look something like:

"main_qml_file": "qml/main.qml"

Paths to defined QML modules and plugins

Felgo Hot Reload can reload files added to Qt modules or plugins if you specify:

The path to the module or plugin source files
The path to the built module or plugin libraries and qmldir file

To add the path to the module or plugin sources:

If not already present in the configuration JSON, add the qml_module_paths key. It contains an array.

Add a new object in the qml_module_paths array. The object has the following keys and their associated values:

path: Add the directory path where the CMakeLists.txt file defines the module or plugin. It must be relative to the configuration JSON file.
target_path: Here, set a path obtained from the module URI by replacing the dots with slashes. For example, for a module with URI Demo.SharedPlugin should be set to Demo/SharedPlugin

To add the path to module or plugin libraries and qmldir file:

If not already present in the configuration JSON, add the qml_plugin_paths key. It contains an array.
Add a new object in the qml_plugin_paths array. The new object has the following keys and associated values:

path: Here, add the path to the folder where the generated qmldir file for this module or plugin is. This path is inside your project’s build directory and must be relative to the configuration JSON file.
target_path: Add a path obtained from the module URI here by replacing the dots with slashes. For example, a module with URI Demo.SharedPlugin should be set to Demo/SharedPlugin. Usually is the same path as the one added for the sources directory.

A full Felgo Hot Reload configuration for a module looks similar to the following:

"qml_module_paths":[

{

"path": "qml_shared_plugin",

"target_path": "Demo/SharedPlugin"

}

"qml_plugin_paths":[

{

"path": "build/MSVC2019_64bit-Debug/Demo/SharedPlugin",

"target_path": "Demo/SharedPlugin"

}

]

Paths to other directories containing QML files or other resources

Felgo Hot Reload can reload files not added to any Qt module or plugin. In this case, you have to specify only the path to the source directory:

If not already present in the configuration JSON, add the qml_module_paths key. It contains an array.

Add a new object to the qml_module_paths array. The object has the following keys and their associated values:

path: Add the path to the directory containing the files. It must be relative to the configuration JSON file.
target_path: add the path where the Qt Resource system expects to find these files. Depending on your configuration, it is one of the following:

The source path directory name when files are not added to the Qt resource system. Note: In this case, you may replace the entire JSON object with the string associated with the path key. For example: "qml_module_paths": ["qml"]
The Qt resource system path for the files. This can be one of the following:

The prefix used inside the project's .qrc file
The prefix specified with qt_add_resources CMake function

Information about loading module and plugin binaries

Felgo Hot Reload creates a local copy of the configured module and plugin libraries. Copying can be unnecessarily time-consuming when running the application locally on your development machine. You can override the behavior with the use_local_plugins key inside the configuration file:

If it's set to true, Felgo Hot Reload will not create the local copy of the libraries. It will use the libraries at the paths from the qml_plugin_paths array.
If set to false, Felgo Hot Reload will make a local copy of the libraries.

Configuring multi-platform projects

Plugin library paths depend on the platform, compiler, and Qt version used. Felgo Hot Reload lets you specify which configuration to use for a given path. The objects inside the qml_plugin_paths array support several optional keys:

compiler: Specify which compiler should use this plugin path. List of possible compilers: gcc_64, android, android_arm64_v8a, android_arm7, android_x86, android_x86_64, clang_64, macos, ios, mingw81_64, mingw_64, msvc2019_64, msvc2022_x64. If not set, Felgo Hot Reload will use the libraries for all compilers.
qt_version: Specify which Qt version this plugin should use. The version is using the MAJOR.MINOR.PATCH string format. If not set, Felgo Hot Reload will use the libraries for all Qt versions.

The configuration for a module used on Linux and Windows development can look like this:

"qml_module_paths":[

{

"path": "qml_shared_plugin",

"target_path": "Demo/SharedPlugin"

}

"qml_plugin_paths":[

{

"path": "build/gcc_64bit-Debug/Demo/SharedPlugin",

"target_path":" Demo/SharedPlugin",

"compiler": "gcc_64",

"qt_version": "6.5.3"

{

"path": "build/MSVC2019_64bit-Debug/Demo/SharedPlugin",

"target_path": "Demo/SharedPlugin",

"compiler": "msvc2019_64",

"qt_version": "6.4.1"

]

Configuring projects with resource aliases

Felgo Hot Reload supports reloading files using a resource alias. Add an entry inside the qml_module_paths array for the resources:

path: Add the path to the directory containing the files. It must be relative to the configuration JSON file.
target_path: The key must be set to the resource alias directory.

For example, if you add resources using the following CMake command:

qt_add_resources(${PROJECT_NAME} "qml_files"

PREFIX "qml/application_logic"

# ${QML_FILES} is a list containing the QML files from the "qml" directory

FILES ${QML_FILES}

)

The configuration looks as follows:

"qml_module_paths": [

{

"path": "qml",

"target_path": "qml/application_logic"

}

]

4. Usage

4.1. Start and connect Felgo Hot Reload

Double-click the FelgoHotReload executable.
This opens a file selection dialog. Select the path to your project’s QML source folder or the folder containing the hot_reload_config.json file (depending on whether you use the QML module support).

Alternatively, you can start it from the command line by providing the path as an argument, e.g., FelgoHotReload <project-path>, or create a shortcut appending the path to the application executable.

Note: When the Felgo Hot Reload GUI application starts for the first time on Windows, it may request firewall permission. Make sure to allow access.

Start your project configured as mentioned above (with the linked FelgoHotReload library).

A connection dialog pops up.

Select Connect to Local for local development (only available on Desktop platforms).
Enter the Connection ID that is shown in the bottom left corner of the Felgo Hot Reload GUI application and press Connect to Remote to connect as a device to a remote GUI application (use case for on-device testing to connect a device to the local development PC).

Accept the connection request on the Felgo Hot Reload GUI application.
Wait until the project is loaded, and you will be ready.

4.2. Auto-Start Felgo Hot Reload

You can automatically start up a connection or start the application from cached files with the following methods:

By setting the environment variable FHR_AUTO_START=<value>

By passing a command line argument --autostart <value>

Note that setting a command line argument will override the checks for the environment variable, even if the argument is invalid!

The value set for either the environment variable or the command line argument can be the following:

local - Will start a local connection to the server, similarly by pressing the Connect to Local button
cache - Will start the cached version of the application if possible
none - Will not do any auto-start and start up normally.

Use it if the FHR_AUTO_START environment variable is set, but we want to bypass it with the command line argument --autostart none.

<ConnectionID> - Will start a remote connection to the GUI application’s Connection ID specified by <ConnectionID>

<ConnectionID> is a 8 or 12-character ID, without space separating the numbers
For example: --autostart 123456789ABC to automatically connect to a GUI application with the following Connection ID: 1234 5678 9ABC

If the application is not started automatically with the given parameters, the default starting screen will appear, with an error message describing why the auto start was unsuccessful.

4.3. Load from Cache

You can start your application without access to the Felgo Hot Reload GUI application. This option is available only if the project has been loaded at least once without QML errors. To do this, select the “Load from Cache” option.

This will start your application with the latest error-free configuration and without Felgo Hot Reload functionality.

4.4. Use the same configuration for multiple applications

If you define more than one application in your project, you can still use a single configuration file:

add your module and plugin paths for all your applications inside the hot_reload_config.json file
start FelgoHotReload GUI app and select your project directory
pass the --main-qml-file <path-to-qml-file> command line arguments to your application, where <path-to-qml-file> is the path for the main QML file of your application. Path must be relative to the hot_reload_config.json file. Set accordingly for each of your project’s applications.

4.5. Development Instructions

Restarts

You can restart your project application anytime. The Hot Reload GUI application does not need to be restarted and can remain open in the background.

Exception: If you change the JSON configuration, you need to restart the Felgo Hot Reload GUI application.

Development

Make changes in your code and save the file. The changes are applied in the running application. If errors in your code occur or Hot Reload cannot be applied, you see an error overlay with a description.

4.6. GUI application options

There are several actions and configuration options available for the Felgo Hot Reload GUI application.

Disconnect
Use this action when you want to disconnect from the connected client. The application either shows the connection screen again or quits, depending on the “Full Reload” availability.
Clear Log
Use this action when you want to clear the log window.
Full Reload
Use this action when you want the connected client to reload all QML files and reset to its initial application state. Note: This is only visible if the option is supported with the current license key.
Stay on Top
Enable this option to keep the developed application window on top. It has effect only on platforms that support multiple windows.
Logs
Enable this option if you want the Felgo Hot Reload GUI app to capture and display developed application logs.
Auto Clear
Enable this option to clear the log windows before every hot reload update.
Hot Reload
Enable this option to have the hot reload feature active. If disabled, a full reload is performed after every code change. Note: This is only visible if the option is supported with the current license key.
Clear Cache
Use this action to clear the cache for the loaded project.
Remove
Use this action to remove the selected client from the Felgo Hot Reload GUI application.

5. Demo Project

You can also access the demo project via GitHub: https://github.com/FelgoSDK/FelgoHotReloadDemo

The project demonstrates how to add Felgo Hot Reload to an existing project. To run the project, follow the instructions in the README file.

6. Changelog

Version 1.6.0 (2026-04-27)

Highlights

Smarter setup with Automatic Configuration Generation

The server can now auto-detect key project settings, reducing manual setup and helping new projects get started faster.

New Configuration Editor

A newly designed editor makes configuration easier to review and adjust, with clearer structure and improved handling of config values.

New Welcome Wizard

A new onboarding wizard guides first-time setup step-by-step, including project selection/configuration and a finalize flow, so users can get to a working Hot Reload setup more quickly.

Improvements

Dialog improvement when cleaning cache
Various improvements on how the main qml file is treated
Errors happening while parsing configuration now appear on the GUI application instead of the console log
Improved hot reload cmake configuration when using multi-config (msvc) generators
Updated FelgoHotReloadDemo application
Demo mode support
Improved file monitoring. Build directory is now ignored when monitoring changes

Fixes

Fixes crash happening when editing a property list<real>
Fixed module and resource prioritization
Fixed configuration being reset if parsing error happens
Fixed how UTF-8 characters are handled while hot reloading
Fixed error thrown when javascript functions with default parameters were used.
Fixed application getting stuck in “Analyzing” state.
Fixed files not updating anymore after changing them in some editors (vim).

Previous versions

You can access the complete changelog here

7. Felgo Hot Reload Limitations

7.1. The developed application window is not set on top on Linux systems

Description

On Linux systems, the developed application window is not always set on top compared to Windows and macOS systems. This causes the application window to end up behind other windows, in particular use cases.

Workaround

Use the “Always on top” feature of Linux:

Right-click the application window
Select “Always on Top”

7.2. Adding Felgo Hot Reload to a Qt6, gcc_64 project on Linux machines can make the CMake configuration fail

Description

A CMake error stating that the XKB::XKB target has not been found

Workaround

Install libxkbcommon-dev package: sudo apt-get install libxkbcommon-dev

7.3. Removing layer.effects with Qt 6.4.1 makes the parent item invisible

Description

Because of a bug in Qt (https://bugreports.qt.io/browse/QTBUG-109506) for Qt 6.4.1, removing the layer.effect from a QML item makes that item invisible.

Workaround

A workaround to prevent an invisible item is to set the layer.enabled to false as well. This bug was fixed with Qt 6.4.3.

7.4. Using a main_qml_file outside project directory may throw errors when using QML imports with relative paths

Description

Because of how we handle the main_qml_file outside the project directory, relative paths for QML imports may become invalid.

Workaround

Update the import QML relative paths:

Start relative imports with “../”. This will point to the parent directory of the paths defined in qml_module_paths
Build your relative import path from there

7.5. Can’t get rid of the error screen when fixing an error

Description

In some cases. If you fix an QML issue that triggered the Felgo Hot Reload error screen in a different way than reverting the change that caused it, the error is still reported and error screen shown. For example, consider the following component definition:

If you remove the componentColor property, Felgo Hot Reload will show the error screen. You can fix the issue in 2 ways:

Undo your change and add back the componentColor property inside the rectangle
Add the componentColor property in the component root Item

If you choose the second option, the error screen will not disappear.

Workaround

Fix the error by reverting the changes that caused it, or
Full reload your application after fixing the error

7.6. Issues when typing Connection ID on some Android device models when using Qt 6.7

Description

More characters than typed are added when typing the Connection ID on some Android device models. It’s caused by this known Qt issue: https://doc.qt.io/qt-6/android-platform-notes.html#predictive-text in combination with QTBUG-125410

Workaround

Use the Auto-Start Felgo Hot Reload feature, or
Copy and paste the entire Connection ID at once

7.7. Updating font assets in Qt < 6.4.0

Description

No change is observed after removing or updating a font file (eg. .ttf) loaded by a QML FontLoader when using Qt versions before 6.4.0. This is a limitation imposed by the Qt API.

Workaround

Restart your application.

7.8. Using components with identical names from different modules generates unexpected results

Description

In some cases only one of the identical-named components will be used throughout the application.

Workaround

Restart your application.

7.9. Changes to QML files do not trigger UI updates on Linux development machine

Description

In some cases you may notice that changing some QML files does not trigger UI updates on your application. This is most common in large projects. A possible cause is that the system runs out of inotify watchers.

Workaround

Increase the number of inotify watchers on the system. You can do this by executing the following in a terminal:

echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p

7.10. Updating a Qt Quick Controls template does not generate application updates

Description

This is a limitation caused by how the Qt Styles are implemented.

Workaround

You can edit one of the instantiated objects. Once it looks like you expect, copy the code inside the template and restart the application.

7.11. GUI application option states get lost when reconnecting

Description

GUI application options lose their state when reconnecting your application. This is happening only if you had version 1.4.5 or earlier installed, then updated to version 1.4.6 or higher.

Workaround

Remove client from the client list, and reconnect again. Once the client was recreated, the issue no longer occurs.

7.12. Monitoring a qrc resource that has files from different drives on windows

Description

Having a configuration for a single qrc resource where files from different drives are used isnot supported by Felgo Hot Reload.

Workaround

Create separate entries in the configuration for monitoring each drive separately.

7.13. Adding a new file to an already existing module

Description

Since Qt 6.8 introduced the QTP0001 it is not possible to add a new file to hot reload and correctly use it. This is because the qmldir needs to be correctly recreated and that happens at build time.

Workaround

After creating the new file, and adding it to the cmake. Rerun cmake, and do a Full Reload for the application.

8. Contact

If you have any questions, please check the Felgo Hot Reload FAQ page.

If you haven’t found an answer to your question or want to reach us, please do it via the Felgo support inbox:
support@felgo.com