15
News and discussion for the Qt Framework. Subreddit: https://www.reddit.com/r/QtFramework Powered by : @r_channels & @reddit2telegram
Qt Contributors Summit 2026: Oslo in October!
https://www.qt.io/blog/qt-contributors-summit-2026-oslo-in-october
https://redd.it/1szqxhh
@qt_reddit
Missing add definition in cpp
Since the latest update (17.0.0) I've been missing the option to generate a function in the cpp file, only the option to generate Outside or Inside class are showing, and it's driving me kinda crazy, I rolled back to 16.0.2 but it still happens
https://preview.redd.it/u9htik5idrcf1.png?width=274&format=png&auto=webp&s=82882e700575782c07137274b39fd8b095ddc221
https://redd.it/1lzby8f
@qt_reddit
Qt Creator + CMake on Windows is driving me insane (need help)
I’m honestly losing my mind over this and I’m hoping someone here can tell me what I’m doing wrong (or confirm that this setup is just cursed). I’m required to use Qt Creator (Qt 6.11, MinGW 64-bit) for a university course. We’re just supposed to build simple C++ programs (console + later small GUI/game stuff). Nothing crazy. But the environment is completely unstable for me.
Typical experience; I create a new project, first run works fine. Second run... suddenly: “No executable specified in run configuration” or CMake completely breaks (wrong paths, cache pointing to old directories). If I move or rename the project folder ONCE, everything is broken. Build folders seem to corrupt everything. CMakeCache points to directories that don’t even exist anymore and Qt Creator sometimes doesn’t show files correctly or ignores changes. On top of that: Windows (Smart App Control / Defender) randomly blocks my compiled .exe files so, I constantly have to unblock or disable things just to run my own code
Things I’ve already tried: reinstalling Qt multiple times, using different kits (MinGW, LLVM, sticking to MinGW now), deleting build folders and reconfiguring, creating fresh projects from scratch. And still after a short time its broken again.
What I actually want is a simple workflow where I can write code, press build, run program, That’s it.
My questions are:
1. How do you actually use Qt Creator + CMake without it constantly breaking?
2. Is it normal that you basically must NEVER move a project because of CMake?
3. How do you deal with Windows security blocking your own compiled executables?
At this point I’m spending way more time fighting the tooling than actually programming, and it’s killing all motivation. I just dont know what to try anymore and I just want this to work.
Any help or advice would be massively appreciated 🙏
https://redd.it/1sv8ikw
@qt_reddit
Qt Group about to cut up to 200 of 1100 jobs
Or in corporate newspeak; Qt Group Launches Operational Reorganization to Improve Efficiency.
https://www.qt.io/releases/release?slug=insider-information-qt-group-launches-operational-reorganization-to-improve-efficiency
https://redd.it/1stma3v
@qt_reddit
the "native" Qt way to handle thread-safe ref-counting.
# Conclusion
Writing a Qt app is a balance between classical RAII and hierarchical ownership. Trying to use *only* smart pointers is a fight against the framework. Understand where Qt takes responsibility and where it leaves it to you, and your code will stay crash-free.
**TL;DR:** Qt's parent-child system and QML's garbage collector manage memory in ways that conflict with `std::unique_ptr`. Raw pointers are still "first-class citizens" in Qt, provided you understand the ownership rules.
https://redd.it/1ss960j
@qt_reddit
Did I misunderstood a code segment or is it just nonsense?
I was trying to learn reason for a bug in qBittorrent and have stumbled onto this file. It seems like constructor sets variable m_storeSmartEpisodeFilter to instance of QString, and then this method tries to .get() filter from it, but as far as I can tell from documentation it doesn't have that method, and even if it did, it would just spit out RSS/AutoDownloader/SmartEpisodeFilter.
I don't have much knowledge in C++ or qt in particular, so maybe it does something that I don't understand.
https://redd.it/1spwa2m
@qt_reddit
Opinions and advice on futureproofing when going c++/MFC > net/avalonia or c++ > c++/QT
Original post in:
https://www.reddit.com/r/dotnet/comments/1sp5mln/opinions\_and\_advice\_on\_futureproofing\_when\_going/
somehow crossposting didn't worked here
I maintain a quite large codebase that is c++ with MFCs as the GUI and for other system relevant stuff (Databases, Filesystem etc) that is partially 30-40 years old and still runs fine but is up for a larger / very large rework. Also a factor: European, so unsure about the future with 100% US products, customers going "no windows!", governments ditching MS, etc
Background:
Why post in r/dontet and others?
I consider switching to net because development speed is about 10 times faster, especially with GUI libs like AvaloniaUI for example and you get cross platform more or less out of the box "for free" included. And the looks are quite better.
The ressource hog of .net is brutal though. POCs have about 10-20x more RAM use then the proven c++ base while only covering below 20% of the features.
What I am concerned in is that, as I understand the .net economy, that is still quite MS depended in how it will live on and that whatever you write needs to be completely maintained to compatibillity with the then current runtime. And if MS kills off the runtime or a feature you depend on you have to start all over. So the vendor lock in into MS stays - as a windows software that was a normal thing but on multi platform...
Now it's runtimes from MS, GUI from Ava, OS runtime Support for the OS one decides to support, a lot of vendors that can kill your day. MFC stuff from Win95 (that was 30 years ago) still works without maintenance.
The other idea is going c++/QT but the dev speed is about 1/10th of net and that could just be too much on the other hand a lot of old code could be reused and it can be rolled over gradually, and that may cut the time into a batch that is manageable. With .net its a complete rewrite. Would loose the vendor lock in of MS but would gain the QT lock.
No one knows for sure but at the moment I miss my usual gut feeling about loglivety of ecosystems and the tripple+ vendor lock in is unnerving.
I fear that saving time and complexity now instead of staying c++/MFC or using something like c++/QT (what if QT abadons features or Operating Systems or closes it's doors in 10 years?) may hit me like a brick wall at lightspeed in a decade or two.
What are your thoughts of the safety / risk of an ecosystem change?
How stable and long living your gut says .net is?
Are there other options I don't see at the moment?
https://redd.it/1sp5rkz
@qt_reddit
Is name Qt from initials of Quasar Technologies?
I saw the Qt timeline that the Qt project was started first and then it's creators Haavard Nord and Eirik Chambe-Eng registered the 1st company called Quasar Technologies, but is that what they had in mind when they started the project, Quasar Technologies, as a project and then they just used the initials Qt?
Does anyone know for sure?
https://redd.it/1snaicv
@qt_reddit
Built an open-source Qt6 / PySide6 bridge for OsmAnd offline maps
/r/gis/comments/1sn3hqq/built_an_opensource_qt6_pyside6_bridge_for_osmand/
https://redd.it/1sn49rx
@qt_reddit
I created a C++/QML music learning app to learn QML
https://redd.it/1sn1oc1
@qt_reddit
LLMQore 0.3.1 — full MCP support for Qt/C++
First things first: renamed the library from LLMCore to LLMQore — because I googled my own lib and couldn't find it.
The main thing in this release is full MCP (Model Context Protocol) support. Server, client, stdio and Streamable HTTP. Connect any MCP server to your LLM client with a one-liner or a JSON config.
mcp-bridge example
chat with mcp tools example
MCP Bridge — a new standalone tool that makes it easy to connect Claude Desktop and other clients to MCP servers that don't use stdio. I ran into this myself and it was annoying — so I built a fix. Prebuilt binaries for Linux, macOS and Windows are in the release — download, run, done.
Improved demo chat — it now shows connected MCP servers and their tools. For example, you can install the Qt Creator MCP server via Extensions and try it right from the demo. A nice way to see how everything works together.
Give it a try — send your usage examples, we'll add them to the examples list. Bug reports are welcome too.
👉 Repo + binaries: github.com/Palm1r/llmqore
https://redd.it/1smjit1
@qt_reddit
I built an MS Paint alternative for macOS
One thing that has always bothered me about macOS is that, unlike Windows, it doesn’t really come with a simple built-in paint app.
I don’t use tools like MS Paint every day, but I think they’re important because ideas disappear quickly. Sometimes you just need to open something instantly and sketch a thought before it’s gone.
I used to work around that by always carrying a notebook and pen. But I wanted that same low-friction experience on my computer too, something that feels as immediate as grabbing pen and paper while I’m already sitting at my desk.
So I built Vincent, a lightweight sketching app written in C++ with Qt. I chose Qt because I wanted a consistent experience across macOS and Linux, and because I wanted it to feel fast. Compared to Electron-style apps, it’s much lighter, and since the UI is very simple, it responds almost instantly.
https://preview.redd.it/q53nw9b0bbvg1.jpg?width=2880&format=pjpg&auto=webp&s=e6f631f825c4bff6a723536543289fac50f51bc6
It’s not trying to be a full-featured art program. The goal is just to make sketching and note-like drawing immediate and frictionless.
It’s normally $1.99 here:
https://iisacc.com/Store/Vincent
But I’m sharing a direct access link for a while to celebrate finishing it:
https://iisacc.com/Store/Vincent/VincentAccessKeyB8F4E1C79D2A6F53E0B7C1A49D8E2F6A
https://redd.it/1slzq2l
@qt_reddit
Built a study planner app in Qt/C++ – looking for suggestions and feedback
https://preview.redd.it/i9zkjg0pr1vg1.png?width=1112&format=png&auto=webp&s=ebb844e9b2daca38b678a4fc6bc34f581bab798d
I’m in my second semester of uni and working toward declaring computer engineering, and I built a study planner in Qt/C++ that I now use daily. It’s a lightweight desktop app with tasks, groups, messaging, and SQLite storage. I’d appreciate any suggestions on architecture, Qt best practices, or UI decisions.
https://github.com/salem-5/StudySync
https://redd.it/1skskdl
@qt_reddit
Setting the background color of a spinbox
[ Windows 11, style=windows11 \]
I wanted to set the background color of a spinbox. I do not want to use style sheets, because style sheets interfere with Qt's automatic handling of dark mode.
OK, should be straightforward enough: set one of the roles on the spinbox's palette to the desired color.
But which role? After experimentation and reading the sources, the answer seems to be that if the widget's background role (which defaults to Window) is set in the palette, then it uses the Button role. (Huh?!?)
https://github.com/qt/qtbase/blob/d1f8ab0ef8801ee0d3f86e6c4cb7e293f08515c6/src/plugins/styles/modernwindows/qwindows11style.cpp#L3133
I suspect that this is just a bug. Comments indicate that it's derived from controlFillBrush, and that is straightforwardly "if Button is set, use Button". I suspect that in the copy-and-paste the test got updated to "if the background role is set...", but then the consequent got left as "use Button".
Does anybody know anything more, before I file a bug report?
https://redd.it/1sizpw4
@qt_reddit
QPolygon occlusion
Hey, so I am posting this here since I've been struggling with this in the past 2 weeks.
For a school project, I am making a Doom-like game environment with BSP and rendering without any OpenGL or Qt3D. Although not exactly the same, it is still useful to learn all the concepts and develop the programming intuition. The problem is I've hit a roadblock. The renderer we made does not render in columns like Doom. Instead, we use QPolygons. Right now, we have a pretty good game we could submit and get our points, but it render back to front. I'd like to integrate front to back with occlusion but no matter what I've tried, it won't work properly. The closest I got was with QPainterPath, managing visible space with screen size, but even that was heavy on computing power and had some bugs. I'd really like some help on finding a solution to do this occlusion. As or right now, I use a universal version of BSP (Not the one in Doom with subsectors, more of the one like Wikipedia suggests), and QPolygons for rendering, with a few structure like Vertex, Sectors and Linedefs, if this can help. Haven't made the Visplane yet. Thanks a lot to anyone who want to help!
https://redd.it/1shdix7
@qt_reddit
QtFinCharts: Financial charting library for Qt6
https://github.com/h2337/QtFinCharts
https://redd.it/1syerpy
@qt_reddit
Weird QFont and QLabel behaviors
Hi everyone,
I ran into a font rendering inconsistency between QLabels with weird conditions.
Here's a minimal example of my app UI. I thought it was only on the app I'm currently working on, but it seems it's the same in this project too.
So I'm using Segoe UI font (which comes by default on Win 11, what I'm currently on) and I set it to my QApplication, and then retrieve it in MainWindow setupUi method, increment the pixel/point size and set it to my QLabels, but the text rendering is incorrect:
Red underline is added with Paint
The weird part is when I comment the first title setFont here, the rest renders correctly:
Red and green lines added with Paint, first title setFont is commented
Did anyone run is a similar situation or am I missing something about QFont usage, or some clash with QLabels ? Advice or even deeper explanations are more than welcome.
Thanks in advance
https://redd.it/1sxphau
@qt_reddit
PySide 6.11 doesn't build on macos
When trying to build PySide 6.11 it always gives this issue
[ 14%\] Building CXX object PySide6/QtCore/CMakeFiles/QtCore.dir/PySide6/QtCore/qdirlisting_wrapper.cpp.o
pyside-setup-everywhere-src-6.11.0/build/pyside6/PySide6/QtCore/PySide6/QtCore/qdirlisting_wrapper.cpp:152:86: error: no type named 'Default' in 'QDirIterator::IteratorFlag'
::QFlags<QDirIterator::IteratorFlag> cppArg1(QDirIterator::IteratorFlag::Default);
\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\^
pyside-setup-everywhere-src-6.11.0/build/pyside6/PySide6/QtCore/PySide6/QtCore/qdirlisting_wrapper.cpp:168:86: error: no type named 'Default' in 'QDirIterator::IteratorFlag'
::QFlags<QDirIterator::IteratorFlag> cppArg2(QDirIterator::IteratorFlag::Default);
\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\^
pyside-setup-everywhere-src-6.11.0/build/pyside6/PySide6/QtCore/PySide6/QtCore/qdirlisting_wrapper.cpp:232:44: error: no viable conversion from 'QFlags<IteratorFlag>' to 'QFlags<QDirIterator::IteratorFlag>'
QFlags<QDirIterator::IteratorFlag> cppResult = const_cast<const ::QDirListing *>(cppSelf)->iteratorFlags();
Shiboken6 and Shiboken6 generator build fine it only gives this error when building PySide6
On linux it built smoothly
Any ideas on what could be wrong?
Versions:
shiboken6= 6.11.0
Pyside6 = 6.11.0
Qt = 6.11.0
Compiler = tested with AppleClang 14, 16, 17
LLVM = tested with llvm14, llvm18 and llvm22
Macos 14 x86_64 and macos 26 arm64
Even following every step from the official guide results in the same error
https://doc.qt.io/qtforpython-6/building_from_source/macOS.html
https://redd.it/1sus0hu
@qt_reddit
A question regarding Qt for Linux, GCC vs pure Clang ambiguity.
This is regarding edge case scenarios related to correctness.
Official 'Qt for Linux' guide doesn't mention clang or LLVM anywhere. It's all GCC in there.
Are the Qt libraries carefully designed around the GCC specific compiler intrinsics and shits and GNU's implementation of Standard Template Library that it can not be safely built with the pure Clang toolchain and used for serious use cases?
Pure clang is significantly faster to compiler, it can integrate with even faster 3rd party linkers as well. Binaries are noticeably smaller due to libc++ being 10x smaller.
I mean does the Qt have some kind of personal relationship with libstdc++ that we can't link it with libc++?
https://redd.it/1ssl9pz
@qt_reddit
Why you can't just "forget" raw pointers in Modern C++/Qt (and why smart pointers might crash your app)
Modern C++ (11/14/17/20...) has a very clear mantra: *"Forget* `new` *and* `delete`*, use smart pointers."* It’s excellent advice for pure C++. But the moment you open the Qt documentation, raw pointers (`T*`) start jumping at you from every page.
Why is it that even in 2026, you can't write a serious Qt application using exclusively smart pointers? Let’s look at where "smart" code actually breaks the framework’s logic.
# 1. The Ownership Conflict: Parent-Child vs. Smart Pointers
Qt’s core feature is the **Object Tree**. When you pass a parent to a `QObject` constructor (like a `QWidget`), you are delegating memory management to that parent.
**The "Double Free" Trap:**
Imagine trying to be "modern" and using `std::unique_ptr` (or `QScopedPointer`) where a parent already exists:
void createUI(QWidget* parent) {
// Ownership is passed to parent, BUT unique_ptr also thinks it's the owner
auto label = std::make_unique<QLabel>("Hello", parent);
// ... logic ...
} // unique_ptr goes out of scope and calls delete.
**What goes wrong?**
1. `unique_ptr` honestly deletes the object when the function ends.
2. However, the `parent` still keeps a pointer to this label in its internal `children()` list.
3. When the `parent` is eventually destroyed (e.g., closing the window), it tries to delete the already-deleted label.
4. **Result:** Crash / Double Free.
Smart pointers implement static or reference-counted ownership. They simply aren't aware of `QObject::parent()`.
# 2. The Chaos of GUI Lifecycles and QPointer
In GUI apps, object lifetimes are often unpredictable. A button might be deleted because a tab was closed, a dialog was dismissed, or a server signal was received.
If you need to store a reference to an object you *don't* own:
* `std::shared_ptr` won't help (it will keep the object alive when it should have died).
* `std::weak_ptr` only works with `std::shared_ptr`.
Enter `QPointer<T>`. This is Qt’s unique "weak" pointer. It doesn't own the object, but it **automatically turns to** `null` when the target `QObject` is deleted (via `delete` or by its parent). It does this by subscribing to the `destroyed()` signal. You can't achieve this safety with standard smart pointers without fighting the framework.
# 3. QML and the JavaScript Garbage Collector Trap
If you use QML, the pointer situation gets even weirder. When you pass a `QObject*` from C++ to QML, `QQmlEngine::ObjectOwnership` kicks in.
If a C++ object has no parent (`parent == nullptr`), the JavaScript engine might decide **it** owns the object. When the JS Garbage Collector (GC) sees the object isn't used in QML anymore, it deletes it. Your C++ pointer becomes a dangling "bomb" that will crash your app later. Smart pointers are powerless here; they can't control the JS GC.
# 4. Performance and Low-Level API
When working with `QImage::bits()` or OpenGL contexts, you need raw memory access.
uchar* scanline = image.scanLine(y);
for(int x = 0; x < width; ++x) {
// Direct memory access is the only way to hit 60 FPS
scanline[x] = process(scanline[x]);
}
Any smart pointer overhead inside such loops would kill the performance benefits of C++.
# The "Qt Memory Management" Cheatsheet
To avoid losing your mind between two systems, follow these rules:
1. **Creating a QObject with a Parent?** Use a raw pointer. The parent will handle it. `new QLabel("Text", this)` is perfectly fine.
2. **Creating a QObject WITHOUT a Parent?** Use `std::unique_ptr` or `QScopedPointer`. This prevents leaks.
3. **Need to track an object you don't own?** Use `QPointer`. It’s the only safe way to check if a widget is still alive.
4. **Non-QObject (Business Logic)?** Use `std::unique_ptr` (ownership) or `std::shared_ptr` (shared resources).
5. **Passing objects to QML?** Always set a parent or explicitly call `QQmlEngine::setObjectOwnership(obj, QQmlEngine::CppOwnership)`.
6. **Multi-threading?** Use `QSharedPointer`. It’s
[Qt Quick3d] Weekend, and I felt the urge to tinker with the water shader 🌊
https://redd.it/1sp8m2j
@qt_reddit
Qt 5.15.18 Windows/MSVC 2022 build with QtWebEngine
Guys, just so you know.
I have compiled Qt 5.15.18 (latest public GPL Qt 5.x release) with QtWebEngine enabled. I use it primarily for my own FOSS projects, but feel free to use it too.
https://github.com/martinrotter/qt-minimalistic-builds/releases/tag/5.15.18-webengine
https://redd.it/1snrc5l
@qt_reddit
Qt6 learning resources for beginners (MSYS2 + GCC)
Hi everyone,
I’m a beginner in Qt and I’ve just started learning it using MSYS2 with GCC.
At first, I’d like to learn things “the hard way” (coding the UI manually) so I can really understand how everything works under the hood. After that, I plan to move on to QML and Qt Designer.
I’d really appreciate any recommendations for good books or tutorials, especially focused on Qt6. If possible, resources that fit well with this learning approach would be great.
Thanks in advance!
https://redd.it/1sn8zw1
@qt_reddit
PySide6 + Qt Design Studio QML on Raspberry Pi CM5 (aarch64) – missing QtQuick.Studio.* components (no PySide6-DS arm64 wheel)
**Quick Summary:**
PySide6 app with UI made in Qt Design Studio works great on desktop with PySide6-DS, but on Raspberry Pi CM5 (aarch64) the QtQuick.Studio.\* components are completely missing because there's no arm64 wheel. I fixed it by replacing them with plain QtQuick, but I'm looking for better long-term solutions.
for full explanation and if u are interested plz view below:
Hey r/QtFramework (and r/raspberry_pi),
I developed a PySide6 application where the entire UI was designed in **Qt Design Studio** (.ui.qml files).
On my desktop it runs perfectly:
* Wrapper .qml files import QtQuick.Studio.Components, QtQuick.Studio.Effects, etc.
* Loaded from Python using QQmlApplicationEngine.
On the **Raspberry Pi CM5** (official 64-bit Raspberry Pi OS):
* pip install PySide6 works fine.
* But **no PySide6-DS wheel for aarch64** → all Studio modules are unavailable.
**Current workaround:** Replaced Studio components with standard QtQuick / QtQuick.Controls equivalents (e.g. Studio.Rectangle → Rectangle, effects via Layer + shaders). App now runs correctly.
# Looking for better options:
1. Is manually rewriting the components the only realistic way, or is there something cleaner?
2. Has anyone tried / succeeded with:
* Cross-compiling just the qtquickdesigner-components module?
* Building a custom PySide6 wheel with full Design Studio support for aarch64?
* Switching to **Boot to Qt** for Raspberry Pi?
* Native build on the Pi or other distros (like Arch Linux ARM)?
**Extra details:**
* Target: Raspberry Pi CM5 + standard 64-bit Raspberry Pi OS
* App is performance-sensitive but not extremely heavy
* I want to keep using Qt Design Studio on the host if possible
* Cross-compilation environment is available
Has anyone successfully deployed a full Qt Design Studio → PySide6 project on CM4/CM5? What worked best for you?
Any guides, Docker setups, or build tips for the Designer components would be greatly appreciated!
Thanks!
https://redd.it/1sn1jc4
@qt_reddit
Qt Quick 3D performance optimization - Free webinar (May, 6 and May, 11)
We are hosting a webinar with our Software Engineers Benjamin and Sakaria on optimizing 3D UIs for target hardware.
The webinar covers the decisions that most affect 3D performance in practice:
▪Performant meshes: Optimize with e.g., mesh density and the level of detail (LOD)
▪Performant materials: Balance your materials, shaders, etc., against performance
▪Scene environment: Limit the amount of light sources and balance between pre-calculation and real-time, including a volumetric lighting alternative, global illumination techniques, etc.
▪Antialiasing: Make mindful choices on using Super sampling vs. MSAA, FXAA, TAA, and Progressive AA
▪QML best practices: dos and don'ts
Register here:
https://www.qt.io/webinar-optimizing-3d-uis-for-high-performance-on-your-target-hardware
https://redd.it/1sn0hky
@qt_reddit
Interactive collision shape editor in Qt (PySide6) with real-time physics
https://redd.it/1smek6q
@qt_reddit
QML language server in pure Go - standalone LSP, no Qt Creator required
Hey all,
I've been frustrated that the only decent QML tooling has historically lived inside Qt Creator. Editors with LSP support either get nothing or a version of qmlls
that's painful to install outside the Qt toolchain.
So I wrote a standalone one:
https://github.com/cushycush/qml-language-server
It's a single static Go binary that speaks LSP over stdio. No CGO, no shared libs, no Qt install — just drop it in your PATH and point your editor at it. Under the
hood it uses a pure-Go tree-sitter runtime with the tree-sitter-qmljs grammar.
Features (v1.0.1):
\- Hover with documentation for QtQuick, QtQml, QtQuick.Controls, and QtQuick.Layouts types
\- Context-aware completion (types, properties, signal handlers, anchors, imports)
\- Go-to-definition and find-references across the workspace (not just the current file)
\- Diagnostics from parse errors
\- Rename, document symbols, signature help, inlay hints
\- Code actions for common quick-fixes
It also knows about Quickshell types if you happen to be building a desktop shell with QML, but that's a superset — the Qt/QtQuick coverage is the core.
What it isn't:
it's not a full QML type checker. It doesn't understand C++-backed custom types the way qmlls paired with a build does. If you're working on a big Qt
app with lots of
Q_PROPERTY
\-registered C++ classes, qmlls will still give you deeper results. But for editing QML files in VS Code or Neovim without booting Qt
Creator, this should cover most of what you want.
v1.0.1, so there will be rough edges. Bug reports and "it should know about X type/property" requests very welcome.
https://redd.it/1slusew
@qt_reddit
Looking for Open Source Greentech/Environmental projects (Qt/C++ & Graphics focus)
Hi everyone, I’m looking to contribute to open-source projects in the Greentech/Climate-tech space.
I have an intermediate background in C++ and Qt/QML, and I’m coming from a Technical Art background (3D engines, shaders, performance optimization). I'm particularly interested in:
\- Digital Twins for industrial/environmental simulation.
\- High-performance data visualization (OpenGL/Vulkan integration in Qt).
\- Desktop applications for environmental monitoring or GIS.
If you know of any active repositories or organizations that could use help on the UI/Visualization side, please let me know! :D
https://redd.it/1sjapet
@qt_reddit
QNativeInterface and Wayland window/surface?
This was announced in the blog post for when Qt version was something like 6.5, now it is 6.11, and there are no changes here; we still need private headers and calls?
https://redd.it/1sifdvx
@qt_reddit
Who's crazy: me, QML LS, or VSCode?
/r/QML/comments/1sbfj2k/whos_crazy_me_qml_ls_or_vscode/
https://redd.it/1sbfy3p
@qt_reddit
