KDAB

KDAB Training Day - May 8th, 2025

Editor Team — Tue, 05 Nov 2024 12:56:00 GMT

KDAB Training Day - May 8th, 2025

Early-Bird tickets are on sale for the KDAB Training Day 2025 until 2025-03-31 23:59

The KDAB Training Day 2025 will take place in Munich on May 8th, right after the Qt World Summit on May 6th-7th. Choose to buy a combo ticket here (for access to QtWS and Training Day) or here (for access to Training Day only).

Seats are limited, so don't wait too long if you want to participate in a specific course. Tickets include access to the selected training course, training material, lunch buffet, beverages, and coffee breaks. Note: The Training Day is held at Hotel NH Collection München Bavaria, located at the Munich Central Station (not the same location as Qt World Summit).

Get your ticket

Why should you attend the KDAB Training Day?

With over 20 years of experience and a rich store of well-structured, constantly updated training material, KDAB offers hands-on, practical programming training in Qt/QML, Modern C++, 3D/OpenGL, Debugging & Profiling, and lately Rust - both for beginners as well as experienced developers.

All courses provided at the Training Day include central parts of the regular 3- to 4-day courses available as scheduled or customized on-site training. Choosing a compact, learning-rich one-day course, lets you experience the quality and effectiveness of KDAB’s usual training offerings.

Courses available at the KDAB Training Day 2025

QML Application Architecture
QML/C++ integration
Modern C++ Paradigms
Integrating Rust into Qt applications
Effective Modern QML
Integrating Custom 3D Renderers with Qt Applications

QML Application Architecture

In this training, we do a step-by-step walkthrough of how to build a QML-based embedded application from the ground up and discuss some challenges that are typically met along the way.

An important part of that journey is an investigation of where to put the boundaries between what you do in C++ and what you do in QML. We also look at some of the tools and building blocks we have available in QML that can help us achieve well-performing, well-structured, and well-maintainable applications.

This course is for

(Qt) developers looking to improve their understanding of how to construct maintainable and efficient larger-scale QML applications.

Prerequisite

Some real-world experience working on QML applications as well as a basic understanding of Qt and C++.

Get your ticket

QML/C++ Integration

In this training, we start with a recap of fundamentals:

How do we expose C++ API to QML?
How do we make data available to QML?

Afterward, we explore several more advanced techniques, often widely deployed within Qt's QML modules, such as Qt Quick.

This will answer questions such as:

How would I do a Loader like component?
How would I do a Layout like component?

This course is for

Qt/QML developers who are familiar with the QML APIs of QtQuick and related modules and who have wondered how these are implemented and want to use similar techniques in their project-specific APIs.

Prerequisite

Some real-world experience working on QML applications as well as a basic understanding of Qt and C++.

Get your ticket

Modern C++ Paradigms

Modern C++ emphasizes safer, more efficient, and maintainable code through higher-level abstractions that reduce error-prone manual work.

This training will explore key paradigms shaping recent C++ evolution, starting with value semantics in class design, which enhances code safety, local reasoning, and thread safety. We will examine modern C++ tools for creating value-oriented types, including move semantics, smart pointers, and other library enablers.

Next, we will look at expressive, type and value-based error handling.

Finally, we'll cover range-based programming, which enables clean, declarative code and unlocks new patterns through lazy, composable transformations.

This course is for

C++ developers who wish to improve the quality of their code, in particular those who wish to write future-proof APIs.

Prerequisites

Prior professional experience in C++. Experience with the latest C++ standards (C++20/23/26) is a plus. We will use several examples inspired by Qt APIs, so Qt knowledge is also a plus (but this is not going to be a Qt training).

Get your ticket

Integrating Rust into Qt Applications

In this step-by-step course, we start with a Qt/C++ application and add Rust code to it piece by piece. To achieve this, we will cover:

Use of Cargo (Rusts build system) with CMake
Accessing Rust code from C++ with CXX (and vice-versa)
Defining your own QObject types in Rust with CXX-Qt

We discuss when to use Rust compared to C++ to make the best of both languages and how to use them together effectively to make Qt applications safer and easier to maintain.

This course is for

Qt/C++ Developers with an interest in Rust who want to learn how to use Rust in their existing applications.

Prerequisites

Basic Qt/C++ knowledge, as well as basic Rust knowledge, is required. A working Qt installation with CMake and a working Rust installation is needed. We will provide material before the training day that participants should use to check their setup before the training.

Get your ticket

Effective Modern QML

In this training, we look into all the new developments in QML over the last few years and how they lead to more expressive, performant, and maintainable code.

This includes:
- The qt_add_qml_module CMake API
- Declarative type registration
- The different QML compilers
- New language and library features
- New developments in Qt Quick Controls
- Usage of tools like qmllint, QML Language Server, and qmlformat

The focus will be on gradually modernizing existing codebases with new tools and practices.

This course is for

Developers who learned QML back in the days of Qt 5 and want to catch up with recent developments in QML and modernize their knowledge as well as codebases.

Prerequities

Some real-world experience with QML and a desire to learn about modern best practices.

Get your ticket

Integrating Custom 3D Renderers with Qt Applications

Qt has long offered ways of using low-level 3d libraries such as OpenGL to do custom rendering. Whether at the Window, the Widget, or Quick Item level, the underlying rendering system can be accessed in ways that make it safe to integrate such 3rd party renderers. This remains true in the Qt 6 timeline, although the underlying rendering system has changed and OpenGL has been replaced by RHI.

In this course, we look at how the graphic stack is structured in Qt 6 and how third-party renderers can be integrated on the various platforms supported by Qt.

We then focus on the specific case of integrating Vulkan-based renderers. Vulkan is the successor to OpenGL; it's much more powerful but harder to learn. To facilitate the initial use of Vulkan, we introduce KDGpu, a library that encapsulates Vulkan while preserving the underlying concepts of pipeline objects, buffer handling, synchronization, etc.

This course is for

This course targets developers wanting to understand the recent state of the graphics stack in Qt, discover the fundamental principles of modern graphics API, and integrate their custom renderers in their applications.

Prerequisite

Prior knowledge of Qt will be required. A basic understanding of 3d graphics would be beneficial.

Get your ticket

Video from KDAB Training Day 2023 held in Berlin

The post KDAB Training Day - May 8th, 2025 appeared first on KDAB.

CXX-Qt 0.7 Release

Thu, 31 Oct 2024 08:30:00 GMT

CXX-Qt 0.7 Release

We just released CXX-Qt version 0.7!

CXX-Qt is a set of Rust crates for creating bidirectional Rust ⇄ C++ bindings with Qt. It supports integrating Rust into C++ applications using CMake or building Rust applications with Cargo. CXX-Qt provides tools for implementing QObject subclasses in Rust that can be used from C++, QML, and JavaScript.

For 0.7, we have stabilized the cxx-qt bridge macro API and there have been many internal refactors to ensure that we have a consistent baseline to support going forward. We encourage developers to reach out if they find any unclear areas or missing features, to help us ensure a roadmap for them, as this may be the final time we can adapt the API. In the next releases, we're looking towards stabilizing the cxx-qt-build and getting the cxx-qt-lib APIs ready for 1.0.

Check out the new release through the usual channels:

Some of the most notable developer-facing changes:

Stabilized #[cxx_qt::bridge] macro

CXX-Qt 0.7 reaches a major milestone by stabilizing the bridge macro that is at the heart of CXX-Qt.
You can now depend on your CXX-Qt bridges to remain compatible with future CXX-Qt versions.
As we're still pre-1.0, we may still introduce very minor breaking changes to fix critical bugs in the edge-cases of the API, but the vast majority of bridges should remain compatible with future versions.

This stabilization is also explicitly limited to the bridge API itself. Breaking changes may still occur in e.g. cxx-qt-lib, cxx-qt-build, and cxx-qt-cmake. We plan to stabilize those crates in the next releases.

Naming Changes

The handling of names internally has been refactored to ensure consistency across all usages. During this process, implicit automatic case conversion has been removed, so cxx_name and rust_name are now used to specify differing Rust and C++ names. Since the automatic case conversion is useful, it can be explicitly enabled using per extern block attributes auto_cxx_name and auto_rust_name, while still complimenting CXX. For more details on how these attributes can be used, visit the attributes page in the CXX-Qt book.

// with 0.6 implicit automatic case conversion
#[cxx_qt::bridge]
mod ffi {
  unsafe extern "RustQt" {
    #[qobject]
    #[qproperty(i32, my_number) // myNumber in C++
    type MyObject = super::MyObjectRust;

    fn my_method(self: &MyObject); // myMethod in C++
  }
}

// with 0.7 cxx_name / rust_name
#[cxx_qt::bridge]
mod ffi {
  unsafe extern "RustQt" {
    #[qobject]
    #[qproperty(i32, my_number, cxx_name = "myNumber")
    type MyObject = super::MyObjectRust;

    #[cxx_name = "myMethod"]
    fn my_method(self: &MyObject);
  }
}

// with 0.7 auto_cxx_name / auto_rust_name
#[cxx_qt::bridge]
mod ffi {
  #[auto_cxx_name] // <-- enables automatic cxx_name generation within the `extern "RustQt"` block
  unsafe extern "RustQt" {
    #[qobject]
    #[qproperty(i32, my_number) // myNumber in C++
    type MyObject = super::MyObjectRust;

    fn my_method(self: &MyObject); // myMethod in C++
  }
}

cxx_file_stem Removal

In previous releases, the output filename of generated C++ files used the cxx_file_stem attribute of the CXX-Qt bridge. This has been changed to use the filename of the Rust source file including the directory structure.

Previously, the code below would generate a C++ header path of my_file.cxxqt.h. After the changes, the cxx_file_stem must be removed and the generated C++ header path changes to crate-name/src/my_bridge.cxxqt.h. This follows a similar pattern to CXX.

// crate-name/src/my_bridge.rs

// with 0.6 a file stem was specified
#[cxx_qt::bridge(cxx_file_stem = "my_file")]
mod ffi {
...
}

// with 0.7 the file path is used
#[cxx_qt::bridge]
mod ffi {
...
}

Build System Changes

The internals of the build system have changed so that dependencies are automatically detected and configured by cxx-qt-build, libraries can pass build information to cxx-qt-build, and a CXX-Qt CMake module is now available providing convenience wrappers around corrosion. This means that the cxx-qt-lib-headers crate has been removed and only cxx-qt-lib is required. With these changes, there is now no need for the -header crates that existed before. Previously, some features were enabled by default in cxx-qt-lib. Now these are all opt-in. We have provided full and qt_full as convenience to enable all features; however, we would recommend opting in to the specific features you need.

We hope to improve the API of cxx-qt-build in the next cycle to match the internal changes and become more modular.

Further Improvements

CXX-Qt can now be successfully built for WASM, with documented steps available in the book and CI builds for WASM to ensure continued support.

Locking generation on the C++ side for all methods has been removed, which simplifies generation and improves performance. Using queue from cxx_qt::CxxQtThread is still safe, as it provides locking, but it is up to the developer to avoid incorrect multi-threading in C++ code (as in the CXX crate). Note that Qt generally works well here, with the signal/slot mechanism working safely across threads.

As with most releases, there are more Qt types wrapped in cxx-qt-lib and various other changes are detailed in the CHANGELOG.

Make sure to subscribe to the KDAB YouTube channel, where we'll post more videos on CXX-Qt in the coming weeks.

Thanks to all of our contributors that helped us with this release:

Ben Ford
Laurent Montel
Matt Aber
knox (aka @knoxfighter)
Be Wilson
Joshua Goins
Alessandro Ambrosano
Alexander Kiselev
Alois Wohlschlager
Darshan Phaldesai
Jacob Alexander
Sander Vocke

The post CXX-Qt 0.7 Release appeared first on KDAB.

KDAB at Embedded Software Engineering Kongress

Editor Team — Wed, 30 Oct 2024 11:31:00 GMT

KDAB at Embedded Software Engineering Kongress

KDAB is an exhibitor at the Embedded Software Engineering Kongress (ESE) held in Sindelfingen (Germany) from December 2nd to 5th. Registration is already open!

"The ESE Congress is Germany's leading congress for the embedded software industry. Every year in December, over 1,200 professionals meet to learn about current technologies and methods, discuss trends and set the course for the future."

You will find the KDAB booth in the exhibitor hall (next to Slint) where you can view some of our latest demos demonstrated by our experts:

Developing Next Generation UI for an EV Charger

High-quality touch-based interface based on Slint

KDAB and tQCS used Slint, a UI toolkit built with Rust, to overhaul the user interface of SK Signet’s flagship Electric Vehicle charger.

15-inch and 32-inch variants with dynamic dark/light mode
Video playback with FFmpeg and networking with Curl
Windows 10 IoT embedded hardware

Servo WebView for Qt

Servo is a web rendering engine written in Rust

KDAB has built a demo of using CXX-Qt to expose a web rendering engine written in Rust as a component to Qt.

Uses CXX-Qt to bridge between Qt and Servo
User interface built with Qt and QML
Servo renders safely in Rust

Developer Tools for Qt, C++, and Linux

Performance Optimization Tools

A selection of useful developer tools for debugging and profiling

GammaRay: High-level introspection tool for Qt applications
KDDockWidgets: KDAB's Dock Widget Framework for Qt
Clazy Static Code Analyzer: LLVM/Clang-based static analyzer for Qt
Hotspot Profiler: GUI for Linux Perf to analyze profiling data
Heaptrack: Heap memory profiler and analysis GUI for Linux

The post KDAB at Embedded Software Engineering Kongress appeared first on KDAB.

KDAB at Meeting C++ in Berlin

Editor Team — Mon, 30 Sep 2024 11:07:00 GMT

KDAB at Meeting C++ in Berlin

KDAB is a Gold Sponsor at this year’s Meeting C++, a highly recommended 3-day hybrid event for the European C++ community.

Locate the KDAB booth on the entrance level and talk to experts Ivan Čukić and Milian Wolff on any of the event days.

At the booth, you will also get a live demo of KDAB tools like GammaRay, Hotspot, Heaptrack, and Clazy. Want to learn more about profiling tools for C/C++ applications? Watch this video.

Check out the schedule and find out more about the innovative way the organiser, Jens Weller, has set up this event for maximum benefit to the C++ community.

Last year's Keynote by KDAB expert Ivan Čukić:

The post KDAB at Meeting C++ in Berlin appeared first on KDAB.

KDAB at CppCon 2024

Editor Team — Mon, 12 Aug 2024 11:12:46 GMT

KDAB at CppCon 2024

CppCon is the annual, week-long face-to-face gathering for the entire C++ community – the biggest C++ event in the world. This year, CppCon takes place in Aurora, Colorado, near the Denver airport. Including multiple diverse tracks, the conference will appeal to anyone from C++ novices to experts.

At CppCon, you can expect interesting talks and panels, presentations by the C++ community, lightning talks, and evening events.

Meet KDAB!

KDAB’s Nate Rogers and Matt Aber welcome you to the KDAB table at the exhibitor section on September 17th and 18th. Get a live demonstration of our highly appreciated and long-loved tools GammaRay and Hotspot or discuss topics like performance optimization, code modernization, or integration of C++ and Rust.

Are you attending CppCon and want to make sure our paths cross? Let us know by reaching out to charlotte.johansson@kdab.com.

We hope to see you there!

The post KDAB at CppCon 2024 appeared first on KDAB.

Hotspot v1.5.0 released

Fri, 26 Apr 2024 09:30:06 GMT

Hotspot v1.5.0 released

Hotspot is a standalone GUI designed to provide a user-friendly interface for analyzing performance data. It takes a perf.data file, parses and evaluates its contents, and presents the results in a visually appealing and easily understandable manner. Our goal with Hotspot is to offer a modern alternative to perf report, making performance analysis on Linux systems more intuitive and efficient.

ChangeLog for Hotspot v1.5.0

It comes packed with a wealth of code cleanups, bug fixes and new functionality. Most notably, the disassembly view has been further improved with better searching, highlighting and faster performance.

Furthermore, we reworked the authentication mechanism to allow perf record to be run directly, with elevated priveleges, via pkexec, obsoleting the error prone old mechanism (see also https://nvd.nist.gov/vuln/detail/CVE-2023-28144).

We now also fully support Qt6 and KF6, while keeping compatibility with Qt5 and KF5. The AppImage below is still built with Qt5 but it might be the last time that we do this. The next version might become Qt6 only.

Many thanks to the various contributors who help build this software, both by writing code as well as reporting bugs.

To get a more detailed scope over all the changes in this new release, check out the full changelog on GitHub. More information about Hotspot can be obtained on its GitHub page or by watching this video.

Happy profiling everyone 🚀

The post Hotspot v1.5.0 released appeared first on KDAB.

Meet KDAB at Embedded World 2024 - Hall 4-302

Editor Team — Wed, 28 Feb 2024 11:06:00 GMT

Meet KDAB at Embedded World 2024 - Hall 4-302

For the 14th time, KDAB exhibited at Embedded World - The meeting place for the global embedded community! Here, as expected, you got three days of pioneering technologies, solutions, new ideas, and intelligent concepts.

Embedded World took place in Nürnberg, Germany from 9 - 11 April 2024 and the KDAB booth was in Hall 4-302 showcasing outstanding demos featuring Qt, C++, 3D, Slint, Rust, and Flutter.

Visitors could use the code ew24518375 to get a free ticket.

Here are the demos that you will have found at our booth, including an interstellar navigation interface built with Flutter...

Augmenting 3D Support for Machine Control

Interactive 3D rendering using Qt3D

KDAB helped iDig, a provider of excavator machine controls, implement 3D-related work: loading CAD files, mesh data structures and algorithms, and rendering.

Embedded software for the control of machinery
Integrate design models and field data
Highly configurable user interface
Embedded Linux system, C++ & Qt application

Developing Next Generation UI for an EV Charger

High-quality touch-based interface based on Slint

KDAB and tQCS used Slint, a UI toolkit built with Rust, to overhaul the user interface of SK Signet's flagship Electric Vehicle charger.

15-inch and 32-inch variants with dynamic dark/light mode
Video playback with FFmpeg and networking with Curl
Windows 10 IoT embedded hardware

Modernizing an Embedded Charge Amplifier UI with Qt

Multi Value Measurements device brought to market readiness

Starting from a legacy codebase, KDAB implemented a multi-measurement channel architecture, extended the UI, and improved stability and performance to reach production quality. The device helps with verification and quality control processes with sensitive measurements in cramped spaces.

Graphing and Result-Visualization of a High-Precision Measurement Process
User Interface built with Qt and QML
Maintaining 2 Product Variants in 1 Software Solution
Texas Instruments AM335x Sitara, 1 x 1Ghz, with GPU

CXX-Qt - Safe Rust Bindings for Qt

Integration for C++ and Rust applications

KDAB supports and maintains CXX-Qt. 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 used to build Rust applications with Cargo.

Enables Rust and C++ ecosystems to be used in the same application
Allows for idiomatic Rust and C++ code
Integrates easily into existing applications

Flutter on embedded hardware using flutter-pi and CAN-Bus Integration

To demonstrate the capabilities of Flutter on embedded we developed an interstellar navigation interface.

Smooth 3D components, running at 60fps
Physical buttons connected via CAN-Bus (CANopen)
Flutter Embedder: flutter-pi
Image built with Yocto and meta-flutter
Hardware: Toradex Verdin AM62, 4x Cortex-A53, 2GB RAM, PowerVR AXE-1-16M GPU

Developer Tools for Qt, C++, and Linux

A selection of useful developer tools for debugging and profiling

GammaRay: Remote Embedded Introspection

Using GammaRay, we introspect a Qt-based game at runtime on the SteamDeck (which is powered by KDE Plasma).

Inspection of a Qt-based SteamDeck game
Full remote Qt introspection capabilities
Visual forwarding and remote control
Injection without recompilation of target software

Further, there are also Hotspot, Heaptrack, and Clazy, which are all useful helpers to make your code more performant.

Last but not least, for those needing an advanced docking solution for Qt applications, the KDDockWidgets demo.

KD DockWidgets: KDAB's Dock Widget Framework for Qt
Clazy Static Code Analyzer: LLVM/Clang-based static analyzer for Qt
Hotspot Profiler: GUI for Linux Perf to analyze profiling data
Heaptrack: Heap memory profiler and analysis GUI for Linux

Getting Started with Customized Embedded Linux

Free four-part guide for Designing your first Embedded Linux device

Embedded Linux is widely used on embedded devices. Still, it is not trivial to implement. We have created a comprehensive guide, starting from framing the development process, via choosing the software stack and the hardware to setting up your development environment.

Brochures, Whitepapers & Articles

In the booth, we had a digital brochure kiosk with access to all KDAB brochures, whitepapers, and articles. Here, you could easily scan the material you were interested in with your phone or grab a physical copy from our selection.

Whether you like to dive into our multi-part series "Best Practices for Embedded Development" or "Building Hybrid Rust and C/C++ Applications"? KDAB has got you covered.

The free ticket!

We invited folk to visit Embedded World free of charge with our voucher code ew24518375.

The post Meet KDAB at Embedded World 2024 - Hall 4-302 appeared first on KDAB.

KDSoap 2.2.0 Released

Editor Team — Fri, 12 Jan 2024 12:30:00 GMT

KDSoap 2.2.0 Released

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 using Qt, it not only facilitates the creation of client applications for web services but also empowers developers to seamlessly build web services without requiring additional components like dedicated web servers. For further details on KDSoap, visit here.

What's New in KDSoap Version 2.2.0?

Build System Co-installability: The buildsystem now supports the co-installability of Qt 5 and Qt 6 headers. Qt 6 headers are installed into their dedicated subdirectory. This ensures compatibility with client code and allows co-installation with Qt 5.

Client-Side:

WS-Addressing Support: The new release adds KDSoapClientInterface::setMessageAddressingProperties(). This addition enables the use of WS-Addressing support specifically with WSDL-generated services.
SOAP Action Requirement Removal: KDSoap no longer requires a SOAP action for writing addressing properties.

WSDL Parser / Code Generator Changes:

Enhanced -import-path Support: Notable changes have been made to the WSDL parser and code generator, impacting both client and server sides. The update improves -import-path support by incorporating the import path in more areas within the code. This refinement enhances the overall functionality of the parser and code generator.

These updates collectively contribute to a more streamlined and efficient experience for KDSoap users, addressing specific issues and introducing valuable features to facilitate seamless integration with Qt-based applications. For detailed information and to explore these enhancements, we refer to the KDSoap documentation accompanying version 2.2.0 on GitHub.

How to Get Started with KDSoap Version 2.2.0?

For existing users, upgrading to the latest version is as simple as downloading the new release from the GitHub page. If you are new to KDSoap, we invite you to explore its capabilities and discover how it can streamline your web service development process.

As always, we appreciate your feedback and contributions to make KDSoap even better. Feel free to reach out to us with any questions, suggestions or bug reports on our GitHub repository.

Thank you for choosing KDSoap, and happy coding!

The post KDSoap 2.2.0 Released appeared first on KDAB.

CXX-Qt 0.6 Release

Fri, 24 Nov 2023 11:30:26 GMT

CXX-Qt 0.6 Release

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++, QML, and JavaScript.

For 0.6, we're excited to announce that we're on the road to stabilization! 🥳
We've done a (hopefully final) iteration of our API and are now happier than ever to release it.

The new API is now truly in the spirit of CXX.
All implementation has moved out of the #[cxx_qt::bridge] and is now simply outside the bridge, like it is for CXX as well.
To get an overview of the new API, check out our the planned 1.0 API, which is available starting with this release.

Check out the new release through the usual channels:

Some of the more extensive developer-facing changes are listed below.

New CXX-style API

extern "C++Qt"

Like extern "C++" in CXX, the extern "C++Qt" block now only uses a declaration-like syntax to expose functionality to C++/Qt.
This is an extension to CXX's extern "C++" blocks, which allow defining methods as #[qsignal].
These signals can then be emitted from Rust, as well as connected to.

extern "RustQt"

Like extern "Rust" in CXX, the extern "RustQt" block now only uses a declaration-like syntax to expose functionality to C++/Qt.
Most existing features have moved to an attribute-syntax, which should look very familiar to existing Qt developers.

The new API includes:

#[qobject] is now on a type alias to distinguish between QObject and Rust struct clearer
#[qproperty(...)] is now just an attribute on the #[qobject]
#[inherit],#[qsignal] & #[qinvokable] have now moved to attributes of external function declarations. They can also now be freely mixed
#[cxx_override], #[cxx_final], #[cxx_virtual] are now independent attributes rather than imbedded in #[qinvokable]

Support for Qt enums as shared types

Like shared types in CXX, enums for Qt can be declared using a shared enum in the bridge.
These can be defined using the #[qenum] attribute and qnamespace!(...) macro.

Implementation is outside the bridge

Like CXX the implementations on types are now defined outside of the bridge rather than inside.
This allows you to choose the prefix for QObjects, as the hard-coded qobject:: prefix is now simply the name of the #[cxx_qt::bridge] module.

Another great new feature in this release: Connecting to Signals via Rust is now possible!
Simply use the on_[SIGNAL-NAME]/connect_[SIGNAL-NAME] methods generated for each signal.
Closures are supported when connecting to signals as well.

QML modules can now be built

The build system has been improved so that QML modules can now be output by CXX-Qt. This allows for using the declarative syntax of #[qml_element] and #[qml_singleton] on a #[qobject], whereas before Rust QObject types needed to be registered in C++ with the QML engine.

use cxx_qt_build::{CxxQtBuilder, QmlModule};
fn main() {
    CxxQtBuilder::new()
        .qml_module(QmlModule {
            uri: "com.kdab.cxx_qt.demo",
            rust_files: &["src/cxx_qt_bridge.rs"],
            qml_files: &["qml/main.qml"],
            ..Default::default()
        })
        .build();
}

This should also allow for tooling to inspect QML modules that were generated from Rust in the future.

New traits for shaping code generation and interacting with features

Most features of the CXX-Qt code generation are now expressed through Rust traits and can be enabled/disabled or otherwise configured using a syntax similar to CXX shim trait impls.

New features

Custom constructors through cxx_qt::Constructor - this drops the requirement for Default on the Rust struct.
Easy default-constructor implementation through cxx_qt::Initialize.
cxx_qt::CxxQtType trait for reflection and less "magic" methods.

Existing features that can now be enabled/disabled:

Threading through the cxx_qt::Threading trait.
Locking through the cxx_qt::Locking trait.

Thanks to all of our contributors that helped us with this release

Be Wilson
Laurent Montel
Olivier Le Doeuff
Jimmy van Hest
Michael (aka @mmMike)
Cyril Jacquet
Magnus Groß
jimmyvanhest

The post CXX-Qt 0.6 Release appeared first on KDAB.

KDAB at Engineering Design Show UK, October 11th-12th

Editor Team — Tue, 05 Sep 2023 05:29:20 GMT

KDAB at Engineering Design Show UK, October 11th-12th

The Engineering Design Show (EDS) returns to The Coventry Building Society Arena (UK) on the 11th - 12th of October 2023.

EDS has been showcasing mechanical, electronics, and embedded design for over a decade. It's a great show to visit for design engineers who are looking for direct access to the latest products, services and innovations available to the sector.

KDAB will be there! Visit us in booth J16 where our experts will be showcasing some of our latest demos.

When: October 11th-12th

Where: The Coventry Building Society Arena, Judds Lane, Coventry.

Demos

iDig - Interactive 3D embedded system for machine control

Embedded software for the control of machinery
Integrate design models and field data
Interactive 3D rendering
Highly configurable user interface
Embedded Linux system, C++ & Qt application

One platform - three frameworks

One app adapted in different frameworks on the same platform
Ship navigation and status summary
Custom, Torizon-based Linux platform
Implemented on IMX8MP SOM on Toradex Yavia carrier boards

KDAB Tools

GammaRay: High-level introspection tool for Qt applications
KDDockWidgets: KDAB's Dock Widget Framework for Qt
Clazy Static Code Analyzer: LLVM/Clang-based static analyzer for Qt
Hotspot Profiler: GUI for Linux Perf to analyze profiling data
Heaptrack: Heap memory profiler and analysis GUI for Linux

CXX-Qt - Safe Rust Bindings for Qt

Enables Rust and C++ ecosystems to be used in the same application
Allows for idiomatic Rust and C++ code
Integrates easily into existing applications

Rust is a systems programming language focused on safety and high performance

Publications

Designing your first embedded Linux device

If your company is building its first embedded Linux device, you’re going from a relatively easy-to-understand product environment to one that’s software-dependent with thousands of technical decisions to make. Nobody wants the expensive mistake of a failed product, but without previous experience, how do you go about creating an embedded system that is not only successful with customers but also a solid foundation for future innovation?

This is the first module in a whitepaper series on designing your first embedded device; it covers the beginning and end of the product development process.

See you there!

The post KDAB at Engineering Design Show UK, October 11th-12th appeared first on KDAB.

KDAB

KDAB Training Day - May 8th, 2025

KDAB Training Day - May 8th, 2025

QML Application Architecture

QML/C++ Integration

Modern C++ Paradigms

Integrating Rust into Qt Applications

Effective Modern QML

Integrating Custom 3D Renderers with Qt Applications

CXX-Qt 0.7 Release

CXX-Qt 0.7 Release

Some of the most notable developer-facing changes:

Stabilized #[cxx_qt::bridge] macro

Naming Changes

cxx_file_stem Removal

Build System Changes

Further Improvements

Thanks to all of our contributors that helped us with this release:

KDAB at Embedded Software Engineering Kongress

KDAB at Embedded Software Engineering Kongress

Developing Next Generation UI for an EV Charger

Servo WebView for Qt

Developer Tools for Qt, C++, and Linux

KDAB at Meeting C++ in Berlin

KDAB at Meeting C++ in Berlin

Last year's Keynote by KDAB expert Ivan Čukić:

KDAB at CppCon 2024

KDAB at CppCon 2024

Meet KDAB!

Hotspot v1.5.0 released

Hotspot v1.5.0 released

ChangeLog for Hotspot v1.5.0

Meet KDAB at Embedded World 2024 - Hall 4-302

Meet KDAB at Embedded World 2024 - Hall 4-302

Augmenting 3D Support for Machine Control

Developing Next Generation UI for an EV Charger

Modernizing an Embedded Charge Amplifier UI with Qt

CXX-Qt - Safe Rust Bindings for Qt

3D Embedded Interstellar Navigation Interface

Developer Tools for Qt, C++, and Linux

Getting Started with Customized Embedded Linux

Brochures, Whitepapers & Articles

The free ticket!

KDSoap 2.2.0 Released

KDSoap 2.2.0 Released

What is KDSoap?

What's New in KDSoap Version 2.2.0?

How to Get Started with KDSoap Version 2.2.0?

CXX-Qt 0.6 Release

CXX-Qt 0.6 Release

New CXX-style API

extern "C++Qt"

extern "RustQt"

Support for Qt enums as shared types

Implementation is outside the bridge

QML modules can now be built

New traits for shaping code generation and interacting with features

Thanks to all of our contributors that helped us with this release

KDAB at Engineering Design Show UK, October 11th-12th

KDAB at Engineering Design Show UK, October 11th-12th

Demos

iDig - Interactive 3D embedded system for machine control

One platform - three frameworks

KDAB Tools

CXX-Qt - Safe Rust Bindings for Qt

Publications