Skip to content

KDAB Training at Qt World Summit Boston October 29th, 2018

Introductory Courses

Effective 3D in Qt

Duration: One Day Target Audience: Qt developers wishing to integrate 3d technology in their application. Prerequisites: The audience is expected to have familiarity with basic QtQuick and OpenGL concepts, but no in-depth knowledge of them is required.


Starting with the utility and enabler classes (for OpenGL, Vulkan and the upcoming Metal support), we will look at low level support for using OpenGL with QOpenGLWindow for rendering and event handling. We will also look at the support in the Widgets module. Later we will show the technologies available in Qt that allow deep integration of Qt Quick 2 scenes with custom drawn OpenGL content. We will discuss the possibility of simply providing a Qt Quick overlay for an OpenGL scene. The discussion will then proceed to the creation of custom Qt Quick Items drawn using raw OpenGL commands, which can then be used from QML. We will also illustrate how to manually drive Qt Quick’s own rendering if we need to be in complete control of how and when the rendering happens. Finally, we will look at Qt 3D and how to use its scene graphs and frame graphs to create high performance 3d rendering without requiring the specialist knowledge required when accessing OpenGL directly. Along the way we will introduce the Qt 3D renderer and input systems and how they are built on top of a flexible, highly threaded, Entity Component System (ECS) architecture that scales very well and is ripe for future additions. You will learn:

  • How to create windows for 3d rendering
  • How to add a Qt Quick based UI to an OpenGL application
  • How to create custom high performance Qt Quick Items using OpenGL
  • How to integrate your own OpenGL renderer with the Qt Quick Renderer
  • How to construct a basic Qt 3D application
  • How to make a scene graph, display 3D graphical content using geometry, materials, textur
  • How Qt 3D maps onto the graphics pipeline
  • How to extend Qt 3D to use your own custom geometry
  • How to write custom materials and shaders
  • How to completely control the Qt 3D renderer dynamically at runtime using the Frame Graph

Trainer: Mike Krus Senior Software Engineer at KDAB, Mike has been developing with C++ since 1996 and Qt since 2004. He has a broad range of experience in scientific applications, mainly in civil engineering and oil & gas industries. His range of expertise includes C++, QML and interactive 3D visualization software design on desktop and mobile as well as macOS development. Mike is the Qt maintainer for the tvOS platform, one of the core contributors to Qt 3D and is very interested in building mobile applications with Qt, mainly on iOS. He has a PhD in Computer Science. Find it on the list and sign up here.

Multithreading in Qt

Duration: One Day Target Audience: Qt Developers interested in multithreaded programming Prerequisites: Knowledge and experience programming with Qt and C++. A basic understanding of multithreaded programming is an advantage but not required.


Multithreaded programming is essential for developers to create fast and responsive applications on computers, phones, and embedded devices all with an increasing number of cores. Qt offers several mechanisms for multithreading; however, it can be difficult to know which to use and how to steer clear of common pitfalls. This course offers guidance how to write safe and efficient multithreaded code with Qt. Topics include:

  • Basic multithreading concepts (threads, processes, data races, reentrency, shared data)
  • Synchronization primitives (mutexes, semaphores, condition variables)
  • Special concerns for Qt applications (cross-thread signals/slots, QObject thread affinity, the GUI thread)
  • Low-level multithreading with Qt (QThread, QThreadPool, QMutex, etc)
  • High-level multithreading with Qt (QtConcurrent)
  • Threading with Qt Model/View
  • A brief summary of atomic operations

Why learn about Multithreading with Qt? Multithreaded development is a complex subject where it is easy to write code that contains severe bugs yet looks correct. This training will provide a solid foundation for writing safe and effective multithreaded code in Qt applications. Trainer: Jim Albamont Senior Software Engineer at KDAB, Jim has actively developed with Qt since 2001. He has a background in computer graphics and data visualization, including 6 years as the lead developer of a multihreaded 3D visualization tool for financial data built with Qt and OpenGL. He has held Qt training classes throughout the US where he is based. Jim holds an MSc in Computer Science. Find it on the list and sign up here.

Advanced Courses

Profiling and Debugging for Linux

Duration: One Day Target audience: Developers who want to find and fix problems Prerequisites: Knowing the basics of C++ and Qt


This training gives an introduction to various tools, which help developers and testers in finding bugs and performance issues. This variant of the training focuses on Linux. The tools presented cover a wide range of problems, from general purpose debugging and CPU profiling to Qt specific high-level analyzers. Often, it is relatively simple to run a tool, but interpreting the results, or even just using some of the more advanced tools, requires deep technical knowledge. The following tools will be covered: Debugging

  • General purpose debugger: GDB
  • Record and replay, reverse debugging: RR
  • Memory error detectors: AddressSanitizer
  • Thread error detectors: ThreadSanitizer
  • Various Qt built-in features
  • QML debugger
  • GammaRay to investigate internals of Qt Applications

Static Code Analysis

  • Compilers
  • Clazy


  • CPU: Linux perf and hotspot
  • Heap memory: heaptrack
  • QML profiler

Trainer: David Faure Senior Software Engineer who also heads up KDAB’s French office, David is a Qt user since its beginning. He has made numerous contributions to Qt, including new classes for QtCore in Qt 5. David is well known in the KDE project for his work on the web browser and especially on KDE Frameworks. He has taught Qt development at numerous conferences and to companies such as Michelin, Schlumberger and Orange. He has become a specialist in multithreading with Qt, as well as performance optimizations. David holds an MSc in Computer Science. Find it on the list and sign up here.

QML Applications Architecture

Duration: One Day Target audience: QML developers who want to learn about creating large-scale yet maintainable applications Prerequisites: Being comfortable with the basics of QML, as well as some familiarity with developing with C++ and Qt (QObject, signals & slots, properties, etc.)


QML is a great language for expressing user interfaces in a declarative, easy to understand way. It can however be difficult to scale up from small demo applications to fully featured, complex systems without paying too high a price in complexity, performance and maintainability. In this course, we explore different techniques to deal with these issues to enable you to scale up your applications while steering clear from the common pitfalls. Topics include:

  • Custom QML items
  • C++ integration
  • Declarative coding
  • Multi-page application architectures
  • Code organization

Trainer: André Somers Software Engineer at KDAB, André has been using Qt since 2002 when he wrote an open source Qt 2-based flight computer for use in glider planes. Since then, he has applied Qt in a broad range of industries ranging from oil & gas exploration, scientific data manipulation and visualization to medical devices and many more. His main expertise is in C++ and QML. He has taught QML to customers across Europe. André holds a MSc in Philosophy of Science & Technology. Find it on the list and sign up here.

What’s New in C++17?

Duration: One Day Target Audience: C++ developers who want to know more about the new features introduced in C++17. Prerequisites: Knowing the basics of C++11 is a requirement, though more advanced topics will be explained as needed.


Starting with C++11 released in 2011, the C++ language and standard library have steadily evolved. At the end of 2017 the new C++17 standard was released, adding a sizable amount of useful new features. All major compilers already support most (if not all) of its features. In this training, the most useful of the new features introduced in C++17 and its predecessor will be presented. In cases for which these features depend on features introduced in C++11 or C++14, these will be refreshed as well. New library features being presented include the new types std::any, std::optional and std::variant, the new parallel algorithms, filesystem access, std::string_view and new operations on the container classes. The new language features range from ways to improve template code with fold expressions, constexpr if, and class template deduction over improvements of lambdas to structured bindings and initalizers in if and switch statements. Why learn what’s new in C++17? C++ is the language that powers most applications written with Qt. To make the most out of the language, developers need to know its capabilities and pitfalls, and keep up with the incremental changes done in new releases. Doing so rewards them with ways to write easier, faster, cleaner and safer code. Trainer: Guiseppe D’Angelo Senior Software Engineer at KDAB, Giuseppe is a long-time contributor to Qt, having used Qt and C++ since 2000, and is an Approver in the Qt Project. His contributions in Qt range from containers and regular expressions to GUI, Widgets and OpenGL. A free software passionate and UNIX specialist, before joining KDAB, he organized conferences on opensource around Italy. He holds a BSc in Computer Science. Find it on the list and sign up here.