This blog post is part of an ongoing series about the internals of the QML engine. In the last blog post, we covered how the QML engine loads QML files. To recap, QML files are parsed and then C++ objects are created for all elements in the QML file. For example, we saw that when […]

In this series of blog posts, we'll look under the hood of the QML engine and uncover some of its inner workings. The articles are based on the Qt5 version of QtQuick, QtQuick 2.0. Most people know that each element in a QML file is backed by a C++ class. When a QML file is […]

This blog post is part of an ongoing series about the internals of the QML engine. In the last blog post, we covered how bindings in the QML engine work. In this post, we'll examine the different kind of bindings. Some of this content is already covered by my DevDays talk QtQuick Under the Hood. […]

This blog post is part of an ongoing series about the internals of the QML engine. In today's post, we'll examine the concept of custom parsers in QML. Recap In the first blog post of the series, we covered how the QML engine loads QML files. One important concept was that every element in the […]

If you’re a reader of this blog, you probably know that we have a huge amount of quality material on QML and Qt Quick, among other topics. In fact, there is so much material that it can be hard to find what you need. If that sounds familiar, you’ll want to bookmark this page! This […]

Property bindings are one of the most interesting features of the QML language. In QML, when we set a value on a property, the right hand side expression isn't evaluated just once to produce a value, like in a ordinary imperative language. In particular, if the expression involves other properties, then the property we're setting […]

There are a few small, and sometimes already quite old, features in Qt that, when combined, can be a very nice way to deal with assets in your QML application -- especially if some of them live on the file system, some in a resource, and some may need localization or translation. Let's dive in! […]

Using the QML engine and QtQuick scenegraph to introspect and analyze performance. Abstract: A fluid and performant user interface in QtQuick applications is an important factor, especially considering that users increasingly demand an "iPhone-like" experience, while at same time, applications often run on a resource-constrained embedded system. What can be done when a QtQuick application […]

A small new feature that was added to Qt 5.8 is the ability for moc (Qt's meta-object compiler) to extract meta-object information at the namespace level. This means, for instance, that you can have introspection support for enumerations defined in a namespace (not just in QObject subclasses, or classes tagged with Q_GADGET), and use such […]

You've reached the third and final entry of the Instantiating arbitrary Qt Quick components with JSON series. Part 1 and Part 2 can be found at their respective links. The first part focuses on the software design pattern used to dynamically instantiate components. The second one shows how to layout these dynamic components by incorporating […]

Introduction Back in the days when Qt was owned by Nokia, a development team in Brisbane had the idea of making it easy to incorporate 3D content into Qt applications. This happened around the time of the introduction of the QML language and technology stack, and so it was only natural that Qt3D should also […]

Several previous posts have introduced our SlideViewer tool which we created for use in the various trainings we deliver. The tool started out as an experiment, created using basic QtQuick 2 Items. Startup configuration was specified by command line arguments, and a simple Keys.onPressed function provided most of the runtime control: both navigating around the […]

We just released CXX-Qt version 0.6! CXX-Qt is a set of Rust crates for creating bidirectional Rust ⇄ C++ bindings with Qt. It can be used to integrate Rust into C++ applications using CMake or build Rust applications with Cargo. CXX-Qt provides tools for implementing QObject subclasses in Rust that can be used from C++, […]

Clazy 1.5 is now available. This is a small release, mainly focused on bug fixing. Clazy is a clang compiler plugin which emits warnings related to Qt best practices. We'll be showing Clazy at Embedded World, Nuremberg, Feb 26-28, where we are a main Qt partner. You can read more about it in our previous […]

An Example of Rendering with Qt3D In the previous article we learned about the requirements and high-level architecture of Qt3D 2.0. In order to put some of this into context and to give you a concrete example of how it looks to draw something in Qt3D using the QML API, we will now briefly show […]

Expanding your team’s software development capacity is something that most managers will encounter at some point in their careers. There are several ways to do this – three of the most common options are hiring new employees, using a service company, or incorporating onsite contractors. Regardless of which route you choose to go, software certifications […]

The upcoming version of the C++ Standard (C++2a) is proposing to deprecate certain usages of the volatile keyword, by adopting the P1152 proposal (Deprecating volatile). Despite the somewhat "flamboyant" title, the actual deprecated parts are very limited and indeed the paper limits the deprecation to somehow language/library corner cases and/or dangerous antipatterns. For instance certain […]

In the last blog post we gave a very high level introduction to the Qt Quick 2 renderer. We also showed how various signals are emitted by the renderer during the synchronization and rendering steps. In this blog post we're going to discuss those signals and show how they can be used to implement overlays […]

In the last blog post we gave a very high level introduction to the Qt Quick 2 renderer. We also showed how various signals are emitted by the renderer during the synchronization and rendering steps. In this blog post we're going to discuss those signals and show how they can be used to implement overlays […]

For today's blog I would like to share with you the little adventure I had when fixing a very strange bug in Qt. Pop quiz Don't think about this too much, just guess: what does this QML snippet print? There are no JavaScript semantic tricks involved; and using either == or === does not change […]