Even Microsoft, for all its C++ use, has never produced anything better than MFC to this day, and only Windows team cares about XAML C++, others rather use React Native or Webview2 alongside C++.
It is up to third parties to use frameworks like Qt.
Those that think it shouldn't be, end up yak shaving trying to bring UNIX and C concepts to platforms that no longer care about that.
Calling ObjC via your language of choice is like the easiest thing possible, solved multiple times over. Signing and notarizing outside of Xcode is also a solved problem.
IME people bitch about this but when push comes to shove just don’t want to do the required work, typically on flimsy grounds. It’s just not that hard.
The increase in Swift-only frameworks will eventually be a problem but it’s typically not a blocker right now.
Basically no other platform comes even close in terms of ease of use and performance. The best would be to extend that kind of framework on Windows (and/or Linux) and make it work same / similar.
> For instance, Apple's SwiftUI is reportedly slow[1][2][3][4],
This is an attempt to build apps with SwiftUI idiomatics https://aparoksha.dev/ (blog on it here https://www.swift.org/blog/adwaita-swift/). It's implemented using SwiftUI on MacOS, WinUI on Windows and libadwaita on Linux.
IMO, metadata (such as date ranges) could instead be stored as empty links leading each task (or by showing a custom placeholder symbol such as '@'), paving the way for a 'linked' data format while resulting in a same-width list for easy lookups and editing:
- [x] [@](/2025/12/30..31.md (15:30:21)) task 1
- [ ] [@](/2025/12/29..30.md (16:20:31)) task 2
- [ ] [@](/2025/12/28..28.md (14:20:31)) same day task
- [ ] undated nested task
In an ideal world, the task marker could hold a custom symbol and linked metadata itself, but would result in non-standard (GFM) markdown:
- [@](/2025/12/30..31.md (15:30:21)) task 1
- [ ](/2025/12/29..30.md (16:20:31)) task 2
- [ ] undated nested task
Here's a quick history lesson (as I understand it):
- QtWidgets the original C++ QT graphics library.
- Around 2008 or something, they introduced QML and QtQuick. This was basically declarative UI + javascript for logic.
- QtWidgets is considered 'done' and all new features and dev is basically happening in QML / QtQuick.
- ...as described in this post, the current recommended 'best practice' is to avoid writing a pile of javascript spaghetti and bridge between C++ for logic and QML for UI.
So, long story short: We've moved from a robust C++ framework, to a javascript backed framework to 'appeal to the masses', but it's kind of hard to build a whole application that way, and so 'best practice' is to go back and write your logic in C++.
Does that seem weird to anyone else?
> While powerful, Qt Widgets lack some essential modern features, in my opinion, such as declarative UI, bindings, behaviors, anchors, and more. These features enable the creation of beautiful, animated UIs simply and quickly, as seen in QML.
Hum. QML is certainly declarative.
I'd love to see a breakdown of specifically what features you can't do with widgets, and why having a js <-> c++ bridge is better than not having one.
Don't get me wrong; if you want to write a 100% javascript QML application, that's cool. Go for it... but when you're writing a C++ application and choosing, deliberately, to implement you UI in another language and communicate with that UI via a bridge...
...well, let's just say, if you had another option (eg. just use C++), wouldn't that make sense?
Couldn't you do the the same thing with react native components and logic in C++? (You could) Why is this any better than just writing a react native UI? Or a flutter UI?
You could do any kind of UI, even fully native, if you're implementing the application is c++ and then just doing cross language <-> to the ui.
Right?
[1] - https://doc.qt.io/qt-6/qtqml-cppintegration-overview.html
The tooling, that is why.
Having QtCreator, Qt Design Studio, compiling QML to native code, debugging experience.
React Native has all the gotchas from JavaScript and poor tooling for developers that never left the CLI world.
Flutter depends on Dart, a programming language that was rescued from oblivion thanks to Flutter, and is pretty much useless everywhere else.
QML is better suited for apps that want full control of their UIs, styling, etc... Which is a more modern way (doesn't mean better!).
It is clear that the author wants the latter, so QML it is.
And yes, it makes sense to use a different language for the UI in this case, with C++ bindings, C++ is not that great for designing UIs. In fact, with QtWidgets, you typically don't use C++ to design your UI. Instead, you use Qt Designer, a graphical tool that works on .ui files (xml), that are then compiled into C++ classes that your derive from, which is a form of binding between two languages: C++ and .ui/xml. You can use C++ directly, sometimes you have to, like when the UI is dynamically generated, but for something like a dialog box, using the graphical tool is much more convenient.
There’s only one language; no bridge. No javascript.
This is largely my point; qt designer already has a more-or-less declarative ui layout language, you just write your event handlers and code in c.
If “declarative” is the reason you’re using QML (and it’s the only specific reason the OP mentioned) it’s probably the wrong reason to be using it.
Small effects and simple state switches ("disable/hide this group of inputs when the user disables the 'advanced' checkbox") can be written in simple code. The advanced plumbing (custom control rendering, window management) is left to native code.
There's a delicate balance there that I can imagine will be difficult to maintain long-term, but many applications just need a handful of buttons and maybe a text field somewhere to do their job, and that's where QML shines.
For me Qt lost it's way when Trolltech was acquired by Nokia, and the focus became mobile rather than desktop, with different UI requirements resulting in QML/QtQuick being added.
Maybe the earlier addition of QtScript (or even MOC!) was a foreshadowing of what was to come, but in any case what had been a great cross-platform desktop UI toolkit, and the primary C++ one for Linux (with GTK being more C focused) ended up orphaning it's desktop roots to focus on mobile instead, having become a sprawling mish-mash of languages, GUI component technologies and scripting.
And as I wrote to another commenter: "if you avoid writing Javascript code in your QML components, than most of your executable will end up being compiled C++ code. If you do write Javascript code in your QML components, than it could also be compiled to C++ code using the QML script compiler[1[2]."
BTW, I agree that there's not enough good documentation about communicating and connecting C++ and QML code. I hope I could write some tutorials for that in the future as I struggled with that when first delving into this.
I've encountered tons of bugs (many of them still unfixed) that I had to find very ugly workarounds for. Also, while a declarative style UI language can have a lot of benefits, it does also have a lot of limitations. For example, in my application I required a (infinite) canvas to rendering the ink strokes, which would be a perfect job for QGraphicsView, but there is no equivalent in Qt Quick. So I had to roll out my own component (which uses Skia under the hood), but that was quite painful. Since Qt 6, the Qt Quick scenegraph is rendered with a custom RHI backend (abstracting over Vulkan, Metal, OpenGL and DirectX) which I had a lot of trouble integrating with third party engines (I really wish they had a WebGPU backend).
QML feels like a refresh with great ideas, bringing declarative UI and reactive programming. Where it falls short for me is it does not have feature parity with Qt Widgets, so you end up having to roll up your own components, wasting a ton of time. Dealing with layouts in QML is also an exercise in frustration.
Oh, yes!
So use the old one? Your first link literally mentions two ancient frameworks that are not abandoned (win32 and MFC)
But you're right
> So, it's more useful to ask: what do we expect from good native apps?
The challenge, though, is there isn't really a good comprehensive list of those things the would allow you to compare the framework you use to native. And you can't patch everything if you don't even know where the holes are
So that why this is correct...
> Qt apps typically don't look or behave exactly like native apps,
... but this is theoretical
> I'm going to argue that they can.
Yes, of course they can, but to do in reality requires too much effort, so you end up with with the state mentioned in the first part of the quote. (that's the whole point of the framework - to handle that complexity for you, and if the whole huge QT can't do that even though "they can" why do you think a single dev can?)
> At the same time, I've grown fond of Markdown. The idea that all my notes are formatted in a syntax that will essentially last as long as computers exist—plain text—is very reassuring
That's a very common mistake as well. It's true only for very primitive parts of markdown, which is rather limiting for notes, but if you venture into the more complicated extensions/HTML area, then it's not different from any other format - as long as the format codecs work, it's usable. Like, even word doc is plain ugly XML text, so will exist forever?
> rendering the underlying Markdown when the cursor is inside a Markdown-formatted text—was quite challenging.
Indeed, because it's not fit for purpose.
> For example, if the cursor is inside this bold and italicized text it will show as *bold and italicized text*.
So you now have constant layout shifts when you simply move your caret around.
Do UIs built with MFC still look like they were built in the 1990s?
> it's possible to achieve non90s styling qualities using those frameworks
But also if it's not, then use that as an argument instead of the non sequitur of the abandoned new
> Yes, of course they can, but to do in reality requires too much effort, so you end up with with the state mentioned in the first part of the quote. (that's the whole point of the framework - to handle that complexity for you, and if the whole huge QT can't do that even though "they can" why do you think a single dev can?)
Yep. This is why I'm now working on a framework built on top of Qt that takes care of all these small but important details that takes time to figure out that Qt isn't equipped with built-in. For example, smooth swipeable StackView on mobile, support for native text handling on mobile, smooth scrolling on ListViews (that's horrible now), etc etc.
> So you now have constant layout shifts when you simply move your caret around.
That's a feature in such apps (look at Bear, etc). I plan to have an option to disable that so the editor is entirely WYSIWYG.
That being said I find that QML is complete trash. It's fine for simple UIs with minimal logic and prototypes but for anything beyond that you'll always need to implement the logic in C++ and this is where the pain enters the picture. A lot of effort will be spent maintaining the glue code that lets the two worlds comminicate. The tooling is poor and QMLs poor typing makes it hard to ever change anything from types to available methods..
Generally speaking QML has terrible shortcomings in its lack of good typing, debugging abilities, error reporting or general maintainability of the code. It's your typical "write once" platform where the cost comes later if/when you need to maintain and evolve the software later on.
I think the fact that Qt went with Javascript as the scripting language for QML wasn't a smart decision - especially resulting in poor type safety. That said, they have improved the situation by a lot with required properties, Q_ENUM where you can now share enums between C++ and QML etc etc.
I don't agree that QML is just for simple UIs, that's exactly what I tried to demystify - my block editor is a very complex project spanning around 20,000+ lines of code - and still managed to be the most performant block editor in all my tests.
Contrary to you, I love the separation between the logic being written in C++ and UI in QML I think it's absolutely a great combo - QML is such a great language to write UIs in and C++ is a performant compiled language that (I, personally) love writing logic in. Also, communicating between C++ and QML components is straightforward with Q_PROPERTYs and signal and slots.
Yes sure I've heard that Qt6 improves the integration and type safety but I haven't tried that yet myself.
Communicatingn with signals and slots and using Qt Property system is straightforward yes but even more straightforward is to when you don't have to use it. The real problem is when you change your properties or your underlying types or the methods, their names or signatures and NOTHING tells you which part of your QML code will be affected. You just have to.. kinda know. In practice you'll of course miss something and then it'll just blow up at runtime with some "bla bla is undefined" error.
That being said if you're comfortable to use it and find it works for you more power to you. I'll just stick to my widgets. :)
You can pay for the Pro version to use advanced blocks such as kanban, images,Drop cap. Also, the free version limits you to 10 notes.
BUT, I'm planning to change that very soon, I will make all the current Pro features free and the only thing that will cost money will be cloud storage with real-time sync when I'll release the new mobile app.
Yup good plan, tying Pro to cloud features makes sense for subscription model.
Wow just noticed my blog post is on the front page! Will try to respond to all comments here soon.
I mean... is it possible to statically link while giving an option to re-link an application using different set of libraries?
> (1) If you statically link against an LGPLed library, you must also provide your application in an object (not necessarily source) format, so that a user has the opportunity to modify the library and relink the application.
And also answered directly in the section you quoted:
> as long as you provide the object files and allow users to relink your app with a different version of Qt
I decided to build it using Qt (Qt Widgets in c++) mainly because my whole data engine is also in c++. Since it just uses standard windows and dialog boxes; I haven't felt the need to keep up with the latest Qt version. I am still using Qt 5 (I think revision 13 or 15).
I have been contemplating moving to Qt 6. Have users noticed a big difference (e.g. performance) between Qt 5 and Qt 6?
QtQuick uses a different runtime which is (afaik) faster and targets modern graphics backends (eg. Vulcan) in a way widgets does not.
It also uses an a javascript scripting engine.
Saying “they’re both c++” is seems kind of misleading and meaningless right?
It’s probably more accurate to say QML is actively being worked on and receiving performance enhancements and updates and widgets is not, and has not for some time.
So yes, it’s actually pretty unlikely that QML would be slower (depending on what you do with your scripts) but it’s probably not as clear cut as you are suggesting.
QML apps that heavily implement core logic in javascript would be slow as balls.
Not really, if you avoid writing Javascript code in your QML components, than most of your executable will end up being compiled C++ code. If you do write Javascript code in your QML components, than it *could also* be compiled to C++ code using the QML script compiler[1[2].
> QML apps that heavily implement core logic in javascript would be slow as balls.
The entire point is to separate logic and view where logic is written in C++ and QML simply represents the view (which almost end up being built upon simple primitives that *are* C++ objects). So if you keep this separation you get amazing performance with great simplicity and velocity.
People who are going to use it should read the documentation.
“It depends” and “it’s still slow” are the fairest comments I can make about this.
You can't claim something is slow without showing empiric data. I showed mine when I claimed programming Qt C++ and QML together is fast. If you claim otherwise, you need to support it with data.
> The most common performance issues in decently written applications are rendering of invisible items aka overdraw
That's indeed what I found as well! Especially, these hidden items consume a lot of unnecessary RAM. What tools do you know for Qt/QML that can help with this issue?
For another perspective and more details, RenderDoc (or another frame debugger if you have one) is a nice tool as well.
Also don't use Rectangle { color: "transparent" }, use Item {}. An Item has geometry, but doesn't render anything. A transparent Rectangle probably also doesn't render, but it's still (at least slightly) more resource-intensive and makes you look like you don't know what you're doing.
Use Loader, StackView and visible liberally to disable stuff that isn't currently relevant. If unloading causes trouble with lost state, you may be carrying too much state on the QML side.
5d41402abc4b•1mo ago
coffeeaddict1•1mo ago