At KDAB, now we occupy been investigating tricks on how to combine Rust with Qt in a protected and idiomatic manner. The resolution we are currently engaged on is is principal as CXX-Qt. It’s available within the GitHub and on crates.io. This blog submit discusses the hurry of CXX-Qt — the set apart it started, the set apart it would also be frail factual now, and the long race path of the venture. In present so that you can get started with code examples, seek the advice of with our Rust book.

Why Rust?

Over the previous couple of years, Rust has been gaining status in varied sectors, from embedded devices to scalable net services. It brings the promise of efficiency, reliability, and productiveness to every sector into which it has been launched. Along with, Rust is priceless from a security perspective on account of its memory safety. For event, a mighty amount of safety concerns in enormous-scale C or C++ projects tends to be memory-related. By the usage of Rust, we reduce wait on these kind of concerns while sustaining a stage of efficiency that is on-par with other native languages, relish C or C++, and some distance faster in comparison with most other memory-protected languages.

Where Would Rust Be Precious with Qt?

Traditional Qt QML applications are quiet of a few parts:

• C++ plugins that offer fashions and record the alternate good judgment
• QML, which defines the layout and parts of the GUI
• JavaScript, for scripting in QML

Rust has a rich ecosystem of libraries for (de)serialization, async futures, parsing unsafe inputs, threading, and so on. The flexibility to combine these Rust libraries into your Qt application makes a compelling legend. Attributable to this truth, making improvements to your C++ plugins and alternate good judgment is one of the right utilize case for Rust. Attributable to QML’s fast iteration inch and flexibility, we counsel sticking with it for the layout and parts of the GUI.

Existing Alternatives

There are many tactics for combining Rust with Qt, every the usage of various systems to bind between Rust and Qt. We came upon that most solutions are inclined to occupy various of these complications:

• Impart bindings that are no longer idiomatic to Rust and easiest present relate entry to the C++ API
• Calls between C++ and Rust that are unsafe
• They don’t intention utilize of Rust’s solid multi-threading ensures or positive aspects
• They don’t occupy a license that suits the Rust ecosystem
• The are trying to make utilize of Rust for all of the appliance in wish to correct a plugin
• No code generation; developers wish to manually outline the bindings

Our Answer

In space of merely providing bindings for the present C++ API, CXX-Qt makes utilize of Qt’s solid object orientation and meta object system. The library potential that you can outline contemporary QObject subclasses in Rust as a module. These can then be instantiated relish every other QObject in QML, or even C++, if wished.

Every QObject outlined by CXX-Qt is made up of two parts:

• A C++-basically based QObject event that stores and exposes properties and invokable systems
• A Rust struct that implements any invokables, manages interior tell, and handles commerce requests from properties or background threads

CXX-Qt then uses a library known as CXX to communicate between Rust and C++. CXX is additionally being explored by enormous companies, similar to Google, with autocxx. When put next to authorized bindings, CXX creates a bridge between Rust and C++ that is in step with a protected subset of the two languages. By the usage of procedural macros, we cloak the details of the CXX bridge from you as a developer. We additionally present a library of authorized Qt forms that can wrong the C++ Rust bridge safely. We furthermore present mechanisms for Rust background threads to advise and safely substitute the Qt tell on the Qt thread.

All of this ends up in very idiomatic and protected Rust code that can seamlessly engage with existing Qt/C++ and Rust code.

The disadvantage of this potential is that we intention no longer present one-to-one bindings. Attributable to this truth, CXX-Qt must impart and enforce every characteristic across the bridge. Nonetheless, as the major focal point of our resolution is transferring a C++ module to Rust, we take into consideration that, for a majority of instances, we are in a position to be providing either a QObject or a model to QML after which exposing properties, invokables, and indicators on these objects.

Present Bellow and Future Route

CXX-Qt is not any longer manufacturing-ready or stable and is amassed a piece-in-growth. We welcome any feedback on the path of the venture and positive aspects and/or any recommendations it is seemingly you’ll more than most likely need.

In the within the period in-between, the present code is in a local to manufacture the next initiatives:

• Define properties and invokables, exposing them onto a QObject
• Exhaust authorized Qt forms
• Hear for property changes or deal with substitute requests from background Rust threads

In the long race, we thought to add the next initiatives/positive aspects:

• Completely different Qt crude classes (similar to QAbstractItemModel)
• Stabilize the API of macros and pork up the API of Qt forms
• Define and emit indicators
• Enhance the documentation to contain tutorials and examples

In present so that you can make contributions, the code is equipped at https://github.com/KDAB/cxx-qt and documentation shall be came upon at https://kdab.github.io/cxx-qt/book.

Please genuinely feel free to share any recommendations or questions within the blog comments or, as soon as you accumulate, ship us an e mail at knowledge@kdab.com.