Adding secondary screens to Qt products is expensive and complex. Christoph Sterz demonstrates extending Qt applications with WebRTC streaming, allowing access from any modern browser with full bidirectional interaction. Using GStreamer for GPU-based video capture and encoding ensures low latency, while a specialized backchannel handles touch, keyboard, and mouse inputs for complete remote control. Ideal for headless IoT devices, remote maintenance, and offsite quality assurance.

After your remote debugging connection is established, it’s time to solve real-world problems. In this second part, Christoph Sterz demonstrates how to use your remote debugging setup to act as if you were running the code directly on your desktop.

We dive into a real-world scenario: a ship navigation app that crashes on the target device. You'll see how to catch a segmentation fault, interpret stack traces, and identify common pitfalls like lambda lifetime issues in Qt. We also wrap up with QML profiling, showing you how to pinpoint performance bottlenecks and slow frames directly on the hardware.

Oxidize 2026 updates, new episodes in the Qt Widgets and More and CLion series, training and events.

"Works on my machine" is a luxury you rarely have in embedded development. To fix bugs effectively on your target hardware, you first need the right infrastructure. In this video, Christoph Sterz explains the essential setup required for professional-grade embedded debugging.

We start by demystifying debug symbols: where they are hidden in your SDK, how to manage "split debug" files in Yocto, and how to use elfutils to handle your binaries. Finally, we walk through the setup for remote debugging using gdbserver, allowing you to keep your heavy symbol files on your laptop while controlling the application running on your device.

One of the most common frustrations for C++ developers using the standard library’s ranges is the inability to pipe a collection directly into a sort algorithm. While C++20 provides beautiful syntax for filter and transform, sort remains a missing piece in the pipeline - at least until today. In this episode of Qt Widgets and more, we take on the challenge. Join us as we walk through the journey of building a robust, pipeable sort implementation from scratch.

In this episode of Qt Widgets and More, we dive into the common pitfalls of using QProgressDialog recursively and show you how to build a cleaner, more professional solution.

It is straightforward to set a breakpoint on qWarning in Qt Creator, but less so in CLion. In the process of showing you how to do that, Jesper hits a major slowdown when starting the debugger. Watch this episode to learn how to avoid that slowdown, to learn a few different tricks about the debugger, and of course to learn how to set a break point on qWarning.

CLion knows about a lot of Qt types, and it knows how to properly display them, so the QString "Hello World" is displayed as "Hello World", rather than as an array of bytes. This video shows you how to create pretty printers (or renderers as CLion calls them) of your own data types.

Includes: Javier Cordero on how to measure Qt Quick visibility latency; a Customer Showcase on MOTOR Ai, showing how autonomous vehicle passengers users are reassured by a custom built UI, using Slint; 3 new episodes of The Curious Developer with in-depth conversations on modern and Contemporary C++ with Frances Buontempo, Ivan Čukić and Daniela Engert; new releases for both the Qt Widgets and More and CLion series; Oxidize 2026 and training news.

A short trailer for the CLion series by Jesper Pedersen, explaining its use in making you more proficient with your IDE, which may mean the difference between struggling to get the job done on time, and doing an excellent job. Jesper Pedersen, the host of this series, has been using Qt Creator for more than 10 years, and before that he was such a power user of Emacs, that he wrote a book on it.

In this episode of The Curious Developer, Jesper Pedersen talks with Daniela Engert about her path into the C++ Standards Committee, her work on modules, and why she invests personal time and money to help shape the future of the language.

When I ask Qt Creator to generate a new UI class for me, then it references the ui class via a raw pointer, rather than via a smart pointer. I asked Peppe (Giuseppe D'Angelo) if there were any value in me fixing this in all my code. As always, the answer was much more involving than originally anticipated, and very enlightening. Among other things we discussed why you still need to have the destructor implemented in the source file, despite it being empty.

Sometimes a line of code makes no sense on its own, and you want to know how it came around. Who wrote it? When did they write it? And most importantly, what commit was it part of? Git blame inside of CLion helps you answer those questions.

When you rebase or when you merge, there might be a conflict which requires a human to resolve. CLion helps you with that, and guess what, I'll show you exactly that in this video.

During review (possibly just by yourself), you may come to the conclusion that a commit actually contains two changes, and should be split up. This video will show you how to do that, and, in addition to that, also show you the changeset features in CLion.

Disclaimer: This reflects CLion at the time of recording. New versions might be different.

One of the things CLion really excels in, is interactive rebase.

This video will show you how it works.

KDAB helped MOTOR Ai, a Berlin-based autonomous driving pioneer, build a scalable, calming Human-Machine Interface (HMI) for the future of mobility using Slint and a custom 3D engine.

This episode will guide you though a "best practice" model/view example, and on the way show you my latest invention, namely a delegating delegate, which ensures that I not longer need to add delegates to every single column needing it - it just works by magic. At the end I will dive into the Qt source code to find the last piece of the puzzle, while I discover what likely is an oversight, if not even a bug, in Qt itself.

Functional programming isn’t just for Haskell or Lisp — many of its ideas have been part of C++ for years, and modern features like lambdas, std::function, ranges, and std::variant make those ideas easier to use than ever.

In this episode of 'The Curious Developer', Jesper Pedersen talks with Ivan Čukić about how to apply functional programming techniques in everyday C++ without switching languages. Ivan explains what “functional programming in C++” really means, how higher‑order functions show up in the standard algorithms, and how concepts like immutability and sum types can make code safer and easier to reason about.