Building efficient desktop applications requires strategies that address common development bottlenecks. From reducing compilation times with precompiled headers, caching, and distributed builds, to mastering multithreading with sanitizers and safe structures, designing extensible plug-in systems, simplifying configuration via text-based files, and leveraging shared libraries for modularity - these best practices streamline development while boosting performance and maintainability.
This blog examines balancing API stability and flexibility. Internal APIs should remain adaptable for ongoing improvements, while external APIs need stability through versioning (e.g., SemVer) and source compatibility guarantees to avoid breaking clients. It also covers ABI stability for libraries and suggests using a buffer layer to isolate internal changes from public interfaces.
Documenting software architecture isn't just about diagrams - it's about preserving the reasoning behind design decisions. This post explores why high-level documentation matters, how to write it effectively, and which tools and models (like C4 and arc42) help maintain clarity and consistency over time.
This tutorial shows how to display Qt Widget windows in a Qt Quick application, combining the flexibility of both frameworks. Learn how to manage integration through C++, expose widget properties and signals to QML, and build multi-window UIs for desktop or embedded platforms from real world examples.
Qt Quick apps can show a white flash during window resizing due to frame lag. This happens when the window’s background doesn’t match the system theme. Use SystemPalette to set a theme-aware background color, ensuring smooth, consistent visuals across platforms.
Key architectural choices - monolithic vs. microservices - impact scalability and complexity. Planning for multi-user support early prevents costly modifications, while containers enhance consistency and security in deployment. Strong security practices, such as minimizing root access and securing OS vulnerabilities, are essential for resilience. Thoughtful planning ensures a scalable, secure, and maintainable embedded system.
The Need for Simple & Modular QR Generation in QML Recently, our designer Nuno Pinheiro needed to generate QR codes for an Android app in QML and started asking around about a simple way to do this. The best existing QML solution was QZXing, a Qt/QML wrapper for the 1D/2D barcode image processing library ZXing. […]
We implement a realtime 3D Mandelbrot set using quaternions in a fragment shader. We just render a cube hull as geometry. The rest happens in the shader.
Learn how to create the effect of a laser scanning an object using the Iro Materials coming with KUESA 3D Studio and Blender.
A Kuesa 3D tutorial on creating, managing and exporting multiple animation groups that affect different sets of objects and materials using Blender and its NLA editor.
Qt Design Studio bridges the gap between designers and developers by making designer visions compatible with development tools. This graphical editor for Qt Quick and QML includes a free community version for non-commercial users and is available for Linux.
Handling the needs of different 3D models in the same application over the lifetime of your project can be time consuming.
Watch this video to learn about an easier way to replace a 3D model with another one in the same code base.
Integrating 3D models into applications traditionally requires developers to request parts from designers and manually reassemble them repeatedly. Kuesa simplifies this workflow, enabling fast demos and significant time savings without compromising 3D model quality by using designer-created scenes (models + animations) directly rather than manual reassembly.
This video will show you how you debug loading of the plugins, using strace on Linux and procmon on Windows.
In the previous episodes, we created and compiled a plugin for Qt designer. The final part missing is to deploy the files in the right directories.This episode discusses the CMake magic that makes that happen.
In this fourth episode of our mini series on developing plugins for Qt Designer, we finally implement the classes that make up the plugin.
Before you create a plugin, your classes may be configured using constructors like:
class Wishes {
public:
Wishes(bool isExclusive, const QColor& color, QWidget* parent);
...
}
But how do you handle these parameters if your constructors can't take anything but the parent pointer? This episode will discuss a few different possible solutions.
In this first episode on developing plugins for Qt Designer, we will discuss the widget promotion feature and its shortcomings compared to plugins.
This is the first video out of 6 on this topic. So, stay tuned!
In this talk, we will explore the process for designing a UX/UI in the embedded space, how we can use Qt and Qt-Creator/Designer as a part of the workflow, and some basic rules for a more pleasing visual experience.
The scene used as the example here is a traditional 3D cube over a simple plane with metallic reflections and a cube reflection on the plane. The scene is done only using QML, 2D tricks and effects and KUESA Iro materials.
