In today’s pervasively digital landscape, building software for a single platform is a 1990s approach. Modern applications, even those designed for specific embedded targets, must be adaptable enough to run seamlessly across various platforms without sacrificing efficiency or reliability. This is often easier said than done. Here are some key points to consider when developing […]

If you work on C++ projects on Windows that need to be built with multiple Visual Studio C++ compiler versions, you need some way to manage the installations of all these build environments. Either you have multiple IDEs installed, or you know about build tools (https://aka.ms/vs/17/release/vs_BuildTools.exe) and maybe keep only the latest full VS IDE […]

The robustness of Linux is widely acknowledged, but it can't quite match the microsecond management of a real-time operating system (RTOS) for time critical situations such as CNC machine instructions, vehicular control, or health sensor collection. If your software must record, manage, or control events within a narrow and precise time window and you’re invested […]

Choosing the right system-on-chip (SoC) is probably your first consideration when designing an embedded product, followed closely by deciding whether to use an off-the-shelf board or design your own. The case for commercial boards in initial designs For the first product in a new line, consider using a commercially available board that features your chosen […]

When designing an embedded product, there’s a lot riding on those crucial first decisions of choosing a hardware vendor and board. Clearly, the hardware you select must be powerful enough to support your product, a challenging determination given that software is usually still in the planning stages at this point in the process. Plus, planning […]

In the beginning, there was C. That sentence actually could serve as the introduction to a multitude of blog posts, all of which would come to the conclusion "legacy programming conventions are terrible, but realistically we can't throw everything out and start over from scratch". However, today we will merely be looking at two ways […]

We're pleased to announce the release of KDSoap version 2.2.0, an update that brings new enhancements to improve both the general build system and client-side functionality. What is KDSoap? KDSoap, a SOAP (“Simple Object Access Protocol“) component rooted in Qt, serves as an essential tool for both client-side and server-side operations. Tailored for C++ programmers […]

Recap Recall that in Part 1 we discussed the differences between OpenGL and Vulkan when it comes to the fixed function parts of the graphics pipeline. We looked at how OpenGL's use of a left-handed set of coordinate axes for clip-space meant that projection matrices for OpenGL also incorporate a z-axis flip to switch from […]

For quite some time, I have been bothered by this thought: Individual programming languages (C++, Rust, Go, etc.) are traditionally viewed as walled gardens. If your main() function is written in C++, you had better find yourself C++ libraries like Qt to build the rest of your codebase with. Do you want to use Flutter […]

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++, […]

In a previous blog we demonstrated the most straightforward method to optimize Visual Studio Code for a Qt / C++ environment: simply let the tools do all the work! The example GitHub project we discussed automatically installs both the Microsoft C/C++ and clangd extensions into VS Code. You might wonder why you need both C++ […]

Our colleague Alessandro Ambrosano created a series of blogs (parts 1, 2, and 3) that explain how to get Visual Studio Code configured for Qt development. In that series, Alessandro covers all the details you need to get your VS Code environment configured exactly the way you want it. But there’s a lot there to […]

Today's blog post is about a small utility class in Qt with a... questionable name: QPointer. If you're new to Qt, maybe don't check out QPointer's documentation just yet, and try to guess what the class does based on its name alone. I've seen countless users being very confused by it. Some end up using […]

When writing large graphics applications in Vulkan or OpenGL, there's many data structures that need to be passed from the CPU to the GPU and vice versa. There are subtle differences in alignment, padding and so on between C++ and GLSL to keep track of as well. I'm going to cover a tool I wrote […]

We're pleased to announce we've added a new library, KDGpu, to the arsenal of tools we invent to make our lives easier - and then share with you on KDAB's GitHub. Who is this for? If you want to become more productive with Vulkan or learn the concepts of modern explicit graphics APIs, then KDGpu […]

Last time we touched upon object lifetime and today we wrap up the basics with a bit of a spicy topic of object ownership. We covered the lifetime quirks, and we found out that manual memory management can be a nightmare, even if we new and delete in the correct order. There must be something […]

An important part of working with Vulkan and other modern explicit rendering APIs is the synchronization of GPU/GPU and CPU/GPU workloads. In this article we will learn about what Vulkan needs us to synchronize and how to achieve it. We will talk about two high-level parts of the synchronization domain that we, as application and […]

Last time we discussed Value Semantics. However, I missed one topic that is super important for a better understanding of basic building blocks of C++. Today, we are going to talk about an object. Without further ado, let’s dive deeper! Object What is an object? According to the C++ standard, part 3.9.8 under the name […]

C++ is an old language. Many aspects of our programming styles have become habits that we do not think about too much today. In this blog, I’m going to address one major issue that has resulted from such habits and get you prepared for a new bright world of C++2b. So without further ado, let’s […]

Background of Shaders One particular facet of modern graphics development that is often a pain - even for AAA games -- is shader variants! If you have bought an AAA game in recent years and wondered what the heck it is doing when it says it is compiling shaders for a long time (up to […]