KDAB/cxx-qt
Cxx Qt
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.
Features
- Qt Framework Integrations - Connects Rust code with Qt and QML interfaces through a bridging layer that safely maps idioms between environments.
- Rust Object Definitions - Describes object structures and behaviors using macros in Rust to automatically generate corresponding C++ representations and bridge definitions.
- QObject Implementations - Allows developers to define QObject subclasses in Rust using macros to expose data and behavior to QML, JavaScript, and C++.
- Macro-Based Code Transformations - Transforms high-level Rust syntax declarations into companion C++ and Meta-Object Compiler files during compilation.
- Qt Signal-Slot Mechanisms - Exposes attributes to bridge Rust logic with Qt's native event and property system for reactive application development.
- Rust Language Binding Generators - Builds bidirectional bindings between Rust and C++/Qt to let both languages communicate and share logic seamlessly.
- Rust Bridges - Connects Rust code with Qt and QML interfaces through a bridging layer for safe interop between languages.
- Rust-C++ Bridges - Translates idioms between Rust and C++ to let developers write idiomatic code in both environments.
- Concurrent Thread Execution - Synchronizes execution paths safely between the primary runtime and native worker threads to prevent data corruption during concurrent operations.
- Thread Synchronization Coordinations - Synchronizes concurrent execution paths safely between the primary event loop and native worker threads to prevent data races.
- Cross-Language Struct Sharings - Passes common framework data structures across the language bridge while maintaining memory safety and native performance.
- C++ Interoperability Layers - Translates language-specific paradigms between distinct runtimes without requiring manual memory management wrappers or unsafe pointer arithmetic.
- C++ FFI Bridges - Generating bidirectional bindings and safely translating data types between Rust and C++ codebases without manual wrapper maintenance.
- QObject Macro Frameworks - Defines QObject subclasses in Rust using macros to expose data and behavior to QML and C++.
- Qt Type Adapters - Shares standard data types across the language boundary using adapters designed for both Rust and Qt environments.
- Language Memory Bridges - Marshals data types safely across the language boundary by enforcing strict ownership rules and wrapping native memory handles.
- Meta-Object Property Mappings - Exposes Rust structs as native event-driven objects that integrate directly into the framework property and signal routing system.
- Task-Pool Coordination - Managing multi-threaded execution paths safely between backend runtimes and graphical frameworks to prevent data races.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
