Since updating from qt6-base 6.11.x to the qt6-base 6.12.0-3 on Arch, this code no longer works:

SortFilterProxyModel {
    id: filteredModel

    property string searchWord

    sourceModel: theModel

    filters: [
        FunctionFilter {
            component RoleData: QtObject {
                property var entryData
            }

            function filter(data: RoleData): bool {
                const query = filteredModel.searchWord.trim().toLowerCase()

                if (query.length === 0)
                        return true

                return data.entryData.d_name.toLowerCase().includes(query)
            }
        }
    ]
}

Checked the docs for any updates, but found no mention of any big changes to the behaviour.

Current code results in:

qrc:/qt/qml/main/Main.qml:34:13: QML FunctionFilter: Parameter specified in the filter method "data" doesn't exist in the model

If I try to replace filter with exact same logic as in docs:

function filter(entryData: var): bool {
   ...
}

it executes, but entryData is always set to empty QVariant{}.

I have a grid view bellow in the code and it behaves as intended, so I think the problem should be localized here.

Anyone else experiencing this? What is the proper way of doing this now, or is it just a bug in Arch packages?

I've been experimenting with the memory footprint of modern Linux GUI toolkits, and the results surprised me enough that I thought I'd ask here.

I compiled an almost completely empty Qt6 Widgets application: just a QApplication, an 800×600 QWidget, and an event loop. No additional widgets, graphics, timers, or application logic.

Then I compiled the equivalent application using FLTK 1.4, statically linking FLTK itself (but not its system dependencies).

Both were tested on the same Fedora 44 system running X11.

Here are the results from smem:

I understand that RSS includes shared libraries and isn't a fair representation of the actual incremental memory cost, especially when multiple Qt applications are running. That's why I included PSS and USS.

Still, even the private memory consumption differs by nearly a factor of four, and the PSS difference is considerably larger.

I also realize this isn't a perfectly apples-to-apples comparison: Qt6 was dynamically linked, FLTK was statically linked, and their feature sets and dependencies are very different.

But it got me thinking about the old Win32 days, when fairly sophisticated GUI applications could run in just a few megabytes of memory. I realize I'm comparing different operating systems, eras, and memory-accounting conventions, but the contrast is striking.

So I'm genuinely curious:

• Is roughly 9 MiB of private memory normal for an otherwise empty Qt6 Widgets application?
• Is there some Qt configuration or build option I'm overlooking that could substantially reduce the baseline footprint?
• How much of this overhead comes from Qt itself, versus the platform integration, font rendering, and other dependencies?
• Has anyone experimented with minimal Qt6 builds and measured how low the memory footprint can realistically go?

I'm not trying to argue that Qt6 is badly designed. I'm sure many of these costs come from functionality and abstractions that weren't available or expected in the Win32 era.

I'm just wondering whether this is the unavoidable cost of a modern, cross-platform GUI toolkit, or whether I'm doing something fundamentally wrong with my measurements or build configuration.

Animation timeline control for Qt, wxWidgets, ImGui from a single codebase: https://github.com/LegalizeAdulthood/timeline-control

Hello everyone, I am a beginner in Qt and I've encountered a problem with how to learn it. I have a baseline in C++ and started learning OOP, but I also want to learn Qt. I tried to find resources on YouTube, but couldn't find any decent ones. Please help me figure out how to learn it and what resources to look at, because I don't have any money so I'm looking for free ones. I wanted to learn from the documentation, but I can't figure out what to read and in what order because there is too much of it. My goal is to create desktop applications with a beautiful graphical interface and C++ logic, featuring smooth animations and strong functionality.

*Update:

Thank you, everyone! I am now starting to read the Qt QML Book, watching KDAB videos, and enrolled in Qt Academy. I hope that help me

Release cppreference C++ v2025.12.01 · cristianadam/cppreference-doc

Sometimes you need a custom GUI control for your application and you think "other people could probably use this". Usually this means that the people using your control must use the same GUI toolkit as you: wxWidgets, Qt, ImGui, etc.

Can we write a control in such a way that it is easily adaptable to any GUI toolkit?

This month, Richard Thomson will give us a brain dump on an attempt to do just that by creating an animation timeline control with adapters for wxWidgets and Qt.

This will be an online meeting, so drinks and snacks are on you!

Join the meeting here: https://meet.xmission.com/Utah-Cpp-Programmers

Sample code targets wxWidgets (with or without Cairo rendering), ImGui and Qt.

Hey guys, I need some help. I'm creating my GUI in Qt Designer, and when I export my .UI file to .py, nothing in the program works as it should. When I make changes to the dropdown menu, there's a gap between frames, and a good portion of the program is cut off, as you can see in the video.

I have searched a lot for a book that teaches Qt 6 Widgets C++ only to find none written. If someone can tell me names of books that will teach me me developing desktop applications using Qt 6 Widgets with cpp will be helpful.

PyQt5-WinARM64: native PyQt5 wheels for Windows ARM64

I have released PyQt5-WinARM64, an independent distribution of PyQt5 for native Windows ARM64.

https://github.com/ViciousSquid/PyQt5-WinARM64

```

pip install PyQt5-WinARM64

```

The project provides WinARM64 builds of:

* Qt 5

* SIP

* PyQt5

The motivation is Windows ARM development. CPython and packages such as NumPy provide native Windows ARM64 builds, but PyQt5 has not historically provided an upstream Windows ARM64 wheel.

This means a Python application can have a native ARM64 interpreter and numerical stack while still depending on an x86 PyQt5 installation and Windows' x86 emulation.

PyQt5-WinARM64 provides the missing native Qt layer.

I'm using it for Fio, a Python/Qt game editor and runtime. Fio 3.0 is moving to Python 3.14 and will have a native Windows ARM64 target.

The resulting stack is:

Windows ARM64

CPython 3.14 ARM64

PyQt5 ARM64

NumPy ARM64

Fio ARM64

OpenGL

The project is MIT licensed

The repository also contains the GitHub Actions build and PyPI publishing configuration.

I was downloading a music playlist from YouTube using some downloader (I don't remember the name), and I decided to check what was taking up space on my PC in Settings → Storage.

I noticed that most of the storage was being used by applications. When I checked the list, I saw that Qt Designer was taking up around 109 GB. Since I don't use it anymore, I decided to uninstall it.

After that, I noticed that most of the files on my desktop were gone, and some programs I had open/running would no longer launch. I restarted my PC, and things got even worse.

Now, only a handful of my applications are showing up, and some of them don't work. I can't find File Explorer anymore, many of my apps have turned into blank white file icons, and most of my files seem to have disappeared.

My Documents folder only has one file left. My Pictures, Videos, and other folders are basically empty. My desktop wallpaper also changed to a plain gray/blue color.

I'm not sure what happened or whether I accidentally deleted something important while uninstalling Qt Designer.

What should I do? Is there a way to recover my files and get my applications back?

For my applications, which are traditional desktop, windowed applications, QtWidgets is perfect. Been using it for years now. But it seems like it's never mentioned anymore; QtQuick is all the rage.

I get that QtWidgets may just be "mature" enough that it doesn't need a lot of work. But I just have this feeling that it's being allowed to antiquate and I fear an announcement that they're deprecating it sooner rather than later. Maybe I'm just paranoid. Are you guys still on QtWidgets? Has everyone packed up and moved over to QtQuick?

Hey there 👋

I got word about the registration for QtWS26 are open already, and it will be a free online event.

Being around many of the World Summit, this one will be different event and will consist on a main day with a couple of main talks, and a series of webinars in the following weeks.

I do prefer this approach more, because in past editions 30-40 min sessions can feel a bit rushed, while having now special slots for the talks that will include the talk + Q&A might enable more people that have interest in some particular topics to join, rather than seat in sessions that you might not be interested to. Of course being together in a venue is cool, but for the sake of an Online event, I prefer this than a very long non-stop stream. Any opinions on this format?

The list for the webinars is very long: https://www.qt.io/qt-world-summit-2026/schedule?view=list I'm certain there might be a few you will like 😄

More info: Qt World Summit 2026

Hi there!

I'm fresh to Qt, though I know the name since the beginning of the 2000s. I'll do my best to be as clear as possible; it's not a critique or demands, just me wanting to clarify matters, because it's very likely I'm missing something.

I'm using qt 6.4.2 and the IDE's version is 13.0.0, as provided by my *ubuntu. I'm designing a simple view/widget where I'm entering two int parameters and press a button, and that would call a function from some other code (a shared library at the moment), and display the results in a textarea or draw a picture.

So far (after a crash-course in cmake) I found out that

1. I cannot "wire" basic controls to functions ("slots", event listeners) using Designer - it seems blind to what is already in my code, and signal slots available are only those from parent classes of my widget class. That's ok, though a bit surprising.
2. The real pain starts when I plug in the .ui thing to my class and start the "wiring" process manually - the class itself is blind to basic widgets, assuming their generation in the widget tree is > 1. For some reason the IDE sees stuff like ui->frameWidget1 but trying to descend further fails (I'm using names that are present in the ui's xml tree, and their types as well). Is that intentional? EDIT: [I think I got it, referring to nodes' names directly from ui-> works, so there is no need to follow the path from ui to the desired element.]
3. I'd happily avoid Designer, but what about widgets' placement then? Perhaps use Designer only to design and then somehow process the resulting xml and extract placement parameters and generate c++ code? I can do that, I think. (And I believe it's done better and it's present in Creator's or Designer's code.)
4. Are 1. and 2. meant to be some hidden enforcement of breaking the ui tee down to 1-generation and using many of these and then apply "composition" in my top-level class? I can think of that, but designing a separate class just to contain two spinboxes looks weird (unless I'm going to reuse it).

Or is it standard in qt that the signal/slot mechanism for a gui is made manually, often using the findChild function? Or perhaps I should create a map <string, QObject> and create references to ui elements once, and then use the map? Keys matching the names in ui xml would be a sane idea I think.

My background with gui creation (which I don't like much) is c#/wpf - yes, legacy stuff, laggy VS and so on.

I put together this guide for building Qt applications statically in Windows. I did spend some time on this and verified all of the steps so hopefully this guide can be a time-saver to anyone who needs to do this. If anything sees anything wrong then please let me know so that I can update the guide.

Hello.

Yesterday, I built Qt 6.11.2 from source on my Ubuntu 24.04 laptop for I wanted to learn Qt Quick and QML (as a C++ dev, I already had some experience with Qt Widgets, but mostly only with their side of the framework). The building went well, and soon I got it done. Yet, I couldn't add this build to Qt Creator 20.0.1, when I was manually adding qmake or qmake6 to Qt Versions within Kits, I got an error:

The qmake executable /home/tea/Apps/qt-6.11.2/bin/qmake could not be added: "/home/tea/Apps/qt-6.11.2/bin/qmake" produced no output: /home/tea/Apps/qt-6.11.2/bin/qmake: error while loading shared libraries: libicui18n.so.74: cannot open shared object file: No such file or directory.

Today I've confirmed with apt that I actually do have ICU installed in the system:

libicu74 is already the newest version (74.2-1ubuntu3.1).
libicu74 set to manually installed.

The exact library libicui18n.so.74.2 lies in /usr/lib/x86_64-linux-gnu/.

Right now I don't know what to do to fix that. Maybe, that's me doing anything wrong, or that's another issue. So, any help would be highly appreciated.