With 55% of developers using CMake as a build tool for C++ code, CMake is the de facto standard build tool for C++. The CMake development team and community are excited that Qt6 will be using CMake as its main build system.

CMake has evolved over the past 20 years and each time a major community adopts CMake, there are features added to support that community. Qt6 is not unique in this respect. Several features have been added to CMake in support of this transition. For example, the ninja build now supports multiple configurations at the same time, automoc support has been improved, and custom commands can add depend information. In addition to covering those new additions and others, this talk will cover what it takes to write modern CMake code taking advantage of the latest paradigms of CMake coding and the new features available to developers.

Currently, Qt Multimedia renders video to a SurfaceTexture which requires the Android framework to access video data. However, in an aircraft, video must play in tunneled mode to provide the best video experience. This prevents the framework from accessing the video data.

In this talk, we will demonstrate how we were able to render a Qt/QML over 4K HDR video in tunneled mode and provide the best passenger experience.

Customer Experience in industrial and commercial environments is sometimes forsaken, but it makes the difference. At Girbau, we have a wide variety of customers with different needs for each of our products. In addition there are internal needs to produce, sell and install our products efficiently.

The process of designing a new hardware and software platform that takes into consideration all those needs is a challenge, but it must be done to provide easy and reliable solutions that bring profitability and innovation to our customers.

BSH Home Appliances GmbH is the leading manufacturer of household appliances in Europe with over 60,000 employees at 39 production sites around the world. User interface development is performed by more than 400 software engineers in Europe, America and Asia.

In this presentation, we will talk about why BSH chose Qt as the UI development toolkit of choice and how we are using and extending Qt to increase software development productivity across a heterogeneous product portfolio. 

Neocis is developing a dental surgery robot and is utilizing Qt to build the key functionalities on the UI of the robot and the planning software. It’s an exciting time for Neocis as they are innovating and creating disruption in their field while working towards a better overall patient experience.

Join Qt Company Senior Product Manager Roger Mazzella as he gets to interview Jim Tieman, Director of Software Engineering at Neocis.

Total War is a multi-award winning AAA games franchise, developed by Creative Assembly, powered by an in-house game engine and tools. There are multiple editors for different purposes, and these large-scale desktop applications are all utilising Qt.

In this presentation, we will take a look at some of these editors, both in terms of what they do for the game-making process, as well as some key Qt features that are used prominently within them.

The multimedia support in Qt has seen some larger changes between 5.15 and 6.2. Those were triggered by architectural issues with Qt Multimedia in the Qt 5 series that made it very difficult to maintain the module with a feature set that is consistent between the different platforms Qt supports.

The talk will focus on the larger architectural and API changes of Qt Multimedia between Qt 5.15 and Qt 6.2, providing insight into the reasons and motivations for many of the API changes. It will present the most important aspects of the API as it is in Qt 6, both for C++ as well as QML. It will show how to use Qt Multimedia to detect connected hardware such as cameras and head sets, how to play back media content and how to capture and record audio and video.

Qt has been under development for many years, and it has been evolving with the community and the development of C++. On the other hand, Python has been around almost the same number of years that Qt, and managed to pass from a just-for-fun into a professional programming language. Due to the increase in popularity of topics related to Data Analysis and Data Science, Python has been playing a main role in the development of many solutions on those topics, but more importantly, most of the performant modules and techniques rely on low-level programming languages like Fortran, C and C++, from which one can extend Python to our own requirements.

The question is, how can we take advantage of that, bringing the functionalities, modules, and even ideas to Qt?

If you are thinking of Python Bindings, that's not enough. Exposing Qt API to Python serves the purpose of enabling Python developers to interact with components most Qt developers have been familiar with for already a long time, but what about Qt/C++ developers?

On this talk we will go through the different approaches on how Python can boost your project, combining both the languages under the Qt framework, extending Python, and embedding Python in your C++ application, and code. Additionally, we will go through a couple of on-going features on the Qt for Python project, which adds new functionality on top of the Qt API we all know. With a basic knowledge of Python, you will take home a couple of clear ideas on how to combine the simplicity of Python into your C++ based applications; how to contribute to the Qt for Python project, and even improve the Python ecosystem.

The presentation is about how Qt can be used for IVI development on Android Automotive platform, with focus on accessing the Vehicle Properties with the Android Car API. You will see how easy the interaction with the car data can be, thanks to the Qt for Android Automotive components.

With the introduction of QML, it was possible to do reactive programming in Qt by creating bindings. With Qt 6's new property system, the same can now be done in C++. This talk gives an introduction to the new property system, and shows how you can benefit from it – both in pure C++ and in mixed C++/QML applications.

Decision support systems require accurate decision support and intuitive interfaces to be accepted by users. When applied to IoT devices residing in varied environments and exists in multitudes of configurations, the decision support needs to be derived at an individual basis and the deployment must be done cross platform. In this talk we will explain how individual device based decision support can be created using Ekkono’s embedded machine learning library and how it can be bundled with an intuitive QT interface and deployed cross platform using QT’s framework.

Ekkono’s machine learning library has a very small footprint and can even do advanced machine learning on devices such as ARM’s M0+. Furthermore, it is not only possible to do inference on pre-trained models, but also to learn on the device. Online learning is a crucial element for providing individual based decision support since it enables the model to adapt to the device and learn its normal behavior. By creating one model per device, the machine learning task is simplified since the model only needs to explain what is normal for a particular device and not why it differs from others. In this way Ekkono can for example create health indicators which will tell the operator when a device needs attention. However, to be accepted by users, decision support systems need intuitive interfaces and integrating Ekkono’s model within a QT application can be easily achieved. In the same time QT’s cross platform capabilities enables deployment to a heterogeneous fleet of devices which is often a reality in the IoT space. In this talk we will present Ekkono’s on-device learning capabilities and how Ekkono has been integrated into QT’s framework to enable fast development of accurate and intuitive decision support systems.

The current legislation in Europe together with the rise of cybercrime makes holding unencrypted private data sets on the server side more a liability than an opportunity. One strategy to counter that is to manage data on the client side and encrypt those when the data pass the Internet or even are stored on servers that could be accessed from outside. The authors have recently gone through the experience of adding encryption to their projects, and would like to share the learnings.

This is not a deep dive into cryptography, and not a rant about data security. This is a talk for common developers who would like to pass information over Internet with reasonable protections along the way but prefer to (and most really should) use already available stacks for that. Even usage of encryption without knowing what you're doing can undermine the purpose, and though Qt does help to do right things, it won't completely cover you. We're going to discuss: - what kinds of encryption one should consider; - what Qt has in stock for that; - what can be taken from elsewhere; - and what implementing encryption in a Qt application ultimately entails, including gotchas we know of.

This talk will show how to best use the new CMake API for QML modules, declarative type registration, and the tools available in Qt to create well-structured, easily maintainable QML applications.

The talk will highlight how such best practices help you compile your QML code to C++ using the new QML Script Compiler. Compiling to C++ avoids interpretation overhead and improves performance of your applications.

Qt Quick Controls comes with a powerful styling API that lets you polish your application to make it stand out with a branded custom theme. It lets you either quickly modify a single control, create your own reusable custom control, or a whole new style from scratch, perhaps by building on top of an existing style. This presentation will take you through the bits and pieces of the styling API, with some additional considerations for desktop applications.

This talks shows which rules you should follow to make your Qt Quick application a long term success. We'll cover topics from QML, Qt Quick and Qt Quick Controls, and explain how to verify those rules via new Qt tooling.

Graphical user interfaces (GUIs) are increasingly present in MCU applications. Typical GUI implementations of microcontrollers are limited by the amount of computing power, peripherals, and memory resources that could be allocated to manage the screens and graphics. Qt for MCUs has a low footprint optimized for microcontrollers. This is one side of the equation. Combining an optimized lightweight graphics engine with a powerful compiler will secure that your GUs in MCU based application can be fast, compact, and energy-friendly.

In this session, we will talk about how to quickly find the optimum solution that balances these requirements. We will discuss size vs. speed optimizations and you will learn how to write compiler-friendly code that will provide you with the best optimization to meet all of these goals. In addition, we will show you which coding constructs are good (and which are not!) from an optimization point of view and how you can leverage C++ to achieve fast and compact code on GUIs in MCU based applications.

The QmlBook is an online resource for learning Qt and QML. It focuses heavily on the QML side of things, but also cover C++ integration. In this talk Johan will discuss the development of the contents, the approach to the text - and ask for feedback on what do you want to see in the book.   The book has been written by, and is maintained by, Johan Thelin and Jürgen Ryannel and has grown to some 20 chapters covering everything from basic QML to Python and C++ integration. The text is built around a set of examples of growing complexity and all examples can be downloaded and used as a starting point for your projects.

Next-generation smart home devices are increasingly interactive, intelligent, and personalized. Join this session to discover how to combine scalable hardware platforms like the i.MX RT Crossover MCUs with Qt for MCUs to provide the flexibility needed to optimize next-generation smart home devices.

The ARM architecture is the most pervasive processor architecture in the world, so having the ability to quickly debug, profile and optimize graphics applications that run on ARM is critical for developer success. In this session, we'll explore the different caveats you may encounter as you develop a modern 3D Graphics Application and encounter some common graphics programming problems. We'll write and debug some shader code, investigate and profile a performance critical workload and identify and fix graphical errors using Nsight Graphics. By the end of the session, you should have a better understanding of how we utilized Qt to build useful features that help developers ensure that their applications run best on NVIDIA GPUs.

Rendering for virtual reality can prove challenging as not doing it correctly can make users feel ill. Qt 6 and the rendering hardware interface (RHI) makes it easier than ever to integrate efficiently with tools like OpenXR to interface with Head Mounted Displays for Virtual Reality.

This talk is will dive into what it took to add support for Virtual Reality into Qt Quick 3D. Some challenging include rendering to native graphics surfaces, 3D input, and physics engine integration. This is an ongoing research project, and should be an exciting view into what is possible with Qt Quick 3D.

Qt 6 introduces a new layer for managing 3D APIs, such as, Vulkan, Metal, Direct 3D, and OpenGL, together with a new pipeline for graphics and compute shaders. Starting with Qt 6.0, both Qt Quick and Qt Quick 3D use the new graphics abstractions as their primary means of rendering 2D and 3D content. Much of this is transparent to the application developer. In certain areas, most prominently the ones that involve working with shader code, there are however changes that affect both public APIs and the way how the designers and developers write shaders.

On top of this all, Qt Quick 3D introduces a new custom material and post-processing effect system. Custom materials are a flexible, simple, yet powerful way to plug in to the shading the default materials perform on a 3D model during rendering. In this live coding presentation we will take a look at the state of Qt Quick and Qt Quick 3D materials in Qt 6.2, with live examples and low-level insights. For those who have implemented 2D-oriented Qt Quick materials or shader effects before, this will provide a hands-on overview of the differences and new features in Qt 6. For designers and developers working with 3D content, the talk will provide a deep dive into the world of custom material system of Qt Quick 3D, exploring some of the possibilities it offers.

Join Jarko to discover how you can add advanced 3D features directly from Qt Design Studio. Continuing the story from 2021 spring's DevDes'21 event - this session focuses on how you can implement nice looking 3D effects into your user interface project directly using Qt Design Studio. Session is split between theory and hands-on as in the session we will be using Qt Design Studio to create a sample application that showcases these features.

Modern 3D UIs are much more than just 3D objects floating around in empty space. This talk looks into how you can create immersive environments in Qt Design Studio, and combine 3D and 2D UI elements into a seamless user experience.

The session is split between theory and live development as we break down our demo in Qt Design Studio to see how it is done.

The talk will show you the best practices to have in mind when developing multi-threaded GUI applications with Qt for MCUs, from the design phase until the testing phase. Using an example Internet music player application, we will see what decisions need to be made when designing UI components, and what are the platform and code optimizations that can be done to get the highest performance and smallest footprint in your application.

Computer-assisted surgeries are changing the nature of today’s operating room (OR). The technology innovations are not only improving outcomes for the patients, but also reducing surgery time and radiation dose for surgeons and OR staff. In this talk, we will start with an overview of the technologies that enable this revolution of pre-operative planning, intra-operative imaging, navigation with optical tracking, and robotics for accurate and robust placement of implants. We will then review how Qt’s core C++ libraries and QML module are leveraged to deliver responsive touch-screen user interface backed by infrastructure of core components ranging from QQuaternion to QCamera. Finally, we will look at how to meet regulatory requirements for Software Development Life Cycle (SDLC) for medical devices with Qt as Off-The-Shelf (OTS) software.

Are you testing enough? This old question is hard, if not impossible, to answer for certain. The measurement of code coverage, i.e. the percentage of code that is being exercised by your test is a very strong indicator. This kind of analysis can even be a must for certification of safety-critical software.

In this talk you will learn how to discover untested parts of your C++ and QML source code. Different coverage levels like Decision Coverage and MC/DC will be explained and compared. And in cases of untestable sections of code, a manual validation can be performed. Coverage data collected for older versions of software can act as an input for the review of changes in new versions. A tool for analysis of patches will be shown.

The Qt 6.2 release brings with it a smoother, simpler and more flexible CMake experience for developers. This talk will highlight some of the flexible ways projects can be structured, with targets being the main focus rather than directories. New capabilities will be demonstrated for adding resources, handling translations and defining QML modules with automatic tooling integration (e.g. linting, compiling to bytecode). CMake features for improving build performance and robustness will also be presented.

For more than a year Jesper Pedersen has hosted a Youtube series focusing on Qt Widgets and everything around developing with it. In this presentation Jesper will highlight some of the most important take away's, including coding tips, and esp those relating to the model/view framework, Qt Creator power tips, and general tips relating to software development tool.

This talk shows how Squish GUI Tester can be used to design and execute cross-platform tests for Qt applications. A few tests will be created for the Qt application running on Windows. Next tests will be executed on the target Linux-based device for the same application. I will demonstrate solutions to handle both environments and differences (screen resolution, starting application / attaching to application) in the single test script codebase.

In this talk we will explore functions that assist developers in both packaging and deploying their Qt applications on the desktop. We will present the Qt Installer Framework and the Qt Desktop deployment tools as well as ways to customize an installer and tools that keep your Qt application continuously updated online.