# kdab/cxx-qt

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/kdab-cxx-qt).**

_How this analysis was created: the description and tags below were written by an AI model that read this project's README and public documentation pages; stars, license and language come straight from the GitHub API. The model does not read the source code._

1,501 stars · 103 forks · Rust

## Links

- GitHub: https://github.com/KDAB/cxx-qt
- Homepage: https://kdab.github.io/cxx-qt/book/
- awesome-repositories: https://awesome-repositories.com/repository/kdab-cxx-qt.md

## Topics

`qt` `qt5` `qt6` `rust`

## Description

CXX-Qt is a framework that connects Rust code with the Qt framework and QML interfaces through a bridging layer that safely maps idioms between environments. It provides a macro-based system that defines QObject subclasses in Rust, exposing data and behavior directly to QML, JavaScript, and C++. 

The framework generates bidirectional bindings during compilation, transforming high-level Rust syntax declarations into companion C++ and Meta-Object Compiler files. It features cross-language type sharing, common data type adaptation for both Rust and Qt environments, and core utility interoperability. 

Concurrency management capabilities synchronize execution paths safely between the primary event loop and native worker threads to prevent data races and corruption during multi-threaded operations. Meta-object property mapping and reactive signal-slot interfaces integrate Rust logic into the native event and property routing system.

## Tags

### Development Tools & Productivity

- [Qt Framework Integrations](https://awesome-repositories.com/f/development-tools-productivity/qt-framework-integrations.md) — Connects Rust code with Qt and QML interfaces through a bridging layer that safely maps idioms between environments. ([source](https://kdab.github.io/cxx-qt/book/))
- [Rust Object Definitions](https://awesome-repositories.com/f/development-tools-productivity/qt-framework-integrations/rust-object-definitions.md) — Describes object structures and behaviors using macros in Rust to automatically generate corresponding C++ representations and bridge definitions. ([source](https://kdab.github.io/cxx-qt/book))
- [Macro-Based Code Transformations](https://awesome-repositories.com/f/development-tools-productivity/ast-transformation-tools/ast-to-source-conversion/source-code-rewriting/compile-time-identifier-rewriting/macro-based-code-transformations.md) — Transforms high-level Rust syntax declarations into companion C++ and Meta-Object Compiler files during compilation.
- [Qt Signal-Slot Mechanisms](https://awesome-repositories.com/f/development-tools-productivity/qt-framework-integrations/qt-signal-slot-mechanisms.md) — Exposes attributes to bridge Rust logic with Qt's native event and property system for reactive application development. ([source](https://github.com/kdab/cxx-qt#readme))
- [Rust Language Binding Generators](https://awesome-repositories.com/f/development-tools-productivity/type-safe-binding-generators/rust-language-binding-generators.md) — Builds bidirectional bindings between Rust and C++/Qt to let both languages communicate and share logic seamlessly. ([source](https://github.com/kdab/cxx-qt#readme))
- [Qt Type Adapters](https://awesome-repositories.com/f/development-tools-productivity/qt-framework-integrations/qt-type-adapters.md) — Shares standard data types across the language boundary using adapters designed for both Rust and Qt environments. ([source](https://kdab.github.io/cxx-qt/book/))

### Part of an Awesome List

- [QObject Implementations](https://awesome-repositories.com/f/awesome-lists/devtools/rust-frameworks/qobject-implementations.md) — Allows developers to define QObject subclasses in Rust using macros to expose data and behavior to QML, JavaScript, and C++. ([source](https://github.com/kdab/cxx-qt#readme))
- [QObject Macro Frameworks](https://awesome-repositories.com/f/awesome-lists/devtools/rust-frameworks/qobject-macro-frameworks.md) — Defines QObject subclasses in Rust using macros to expose data and behavior to QML and C++.

### Programming Languages & Runtimes

- [Rust Bridges](https://awesome-repositories.com/f/programming-languages-runtimes/c-language-bridges/rust-bridges.md) — Connects Rust code with Qt and QML interfaces through a bridging layer for safe interop between languages.
- [Rust-C++ Bridges](https://awesome-repositories.com/f/programming-languages-runtimes/c-language-bridges/rust-c-bridges.md) — Translates idioms between Rust and C++ to let developers write idiomatic code in both environments.
- [Concurrent Thread Execution](https://awesome-repositories.com/f/programming-languages-runtimes/concurrent-thread-execution.md) — Synchronizes execution paths safely between the primary runtime and native worker threads to prevent data corruption during concurrent operations. ([source](https://kdab.github.io/cxx-qt/book/))
- [Thread Synchronization Coordinations](https://awesome-repositories.com/f/programming-languages-runtimes/concurrent-thread-execution/thread-synchronization-coordinations.md) — Synchronizes concurrent execution paths safely between the primary event loop and native worker threads to prevent data races.
- [Cross-Language Struct Sharings](https://awesome-repositories.com/f/programming-languages-runtimes/cross-language-struct-sharings.md) — Passes common framework data structures across the language bridge while maintaining memory safety and native performance. ([source](https://kdab.github.io/cxx-qt/book))
- [C++ Interoperability Layers](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/native-c-interoperability/c-interoperability-layers.md) — Translates language-specific paradigms between distinct runtimes without requiring manual memory management wrappers or unsafe pointer arithmetic.
- [C++ FFI Bridges](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/systems-languages/rust/c-ffi-bridges.md) — Generating bidirectional bindings and safely translating data types between Rust and C++ codebases without manual wrapper maintenance.

### Operating Systems & Systems Programming

- [Language Memory Bridges](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/memory-safety-and-semantics/cross-language-memory-managers/language-memory-bridges.md) — Marshals data types safely across the language boundary by enforcing strict ownership rules and wrapping native memory handles.

### Software Engineering & Architecture

- [Meta-Object Property Mappings](https://awesome-repositories.com/f/software-engineering-architecture/object-property-monitoring/meta-object-property-mappings.md) — Exposes Rust structs as native event-driven objects that integrate directly into the framework property and signal routing system.
- [Task-Pool Coordination](https://awesome-repositories.com/f/software-engineering-architecture/process-coordinators/thread-and-process-synchronization/posix-thread-creation-and-synchronization/task-pool-coordination.md) — Managing multi-threaded execution paths safely between backend runtimes and graphical frameworks to prevent data races.