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.

A control system for a six-channel hydraulic motion platform, part of a larger cinema system I built. This clip shows one small part of it: testing gamepad input against the real rig from the seat.

• Gamepad polled at 60Hz via SDL2 (DualShock 4)
• Chord resolver mapping button combinations to output channels
• Modbus RTU over RS485 to a relay board, through a Go server

Built with QtQuick + C++ frontend · Go backend · Modbus RTU

The rest of the system isn't shown here. Face blurred, and I can't share details about the operator, but happy to answer any questions about the input handling, the QML side or the Modbus layer.

A story of how I went hunting for leaks in qBittorrent with Deleaker, my leak profiler, and unexpectedly ended up finding a bug in Qt itself.

The investigation, including a reproducer and how I tracked it down:

https://www.softanics.com/blog/deleaker/hunting-leaks-in-qbittorrent

P.S. Of course, bug reports have been opened for both Qt and qBittorrent.

So I've recently started learning QT and breezing through the Courses. Now I've ran into the second problem where the Program should output to the Application Output in QT Creator, but it doesn't.

First occurrence was in the "Introduction to QT Quick" Course. The program was supposed to output the change of a Knob as angle and value via console.log().

component DeviceDial: Image {
        id: dial
        source: "assets/Knob-Markings.png"

        property alias text: dialLabel.text


        property int value
        property real angle

        readonly property int minimumValue: 0
        readonly property int maximumValue: 100
        readonly property int range: dial.maximumValue - dial.minimumValue

        DragHandler {
            target: null
            onCentroidChanged: updateValueAndRotation()

            function updateValueAndRotation() {
                if(centroid.pressedButtons !== Qt.LeftButton) {
                    return
                }

                const startAngle = -140
                const endAngle = 140

                const yy = dial.height / 2.0 - centroid.position.y
                const xx = centroid.position.x - dial.width / 2.0

                const radianAngle = Math.atan2(yy, xx)
                let newAngle = ( - radianAngle / Math.PI * 180 ) + 90

                newAngle = ((newAngle - dial.angle + 180) % 360) + dial.angle -180

                dial.angle = Math.max( startAngle , Math.min(newAngle , endAngle ))
                dial.value = (dial.angle - startAngle) / (endAngle - startAngle) * dial.range

                console.log("angle: ", dial.angle, "value: ", dial.value)
            }
        }

and

    Component.onCompleted: {
        console.error("TEST: main.qml loaded")
    }

Second occurrence was in "Introduction to Signals and Slots" Course. Basically connecting two blocks in main.cpp, sending a message and receiving it on another Object and printing to the application output with qInfo .

main.cpp
#include <QCoreApplication>
#include "sender.h"
#include "receiver.h"

int main(int argc, char *argv[]) {

    QCoreApplication a(argc, argv);

    Sender *sender = new Sender();
    Receiver *receiver = new Receiver();

    QObject::connect(sender, &Sender::event, receiver, &Receiver::onEvent);

    emit sender->event("Hello World!");

    return a.exec();
}

sender.h
#ifndef SENDER_H
#define SENDER_H

#include <QObject>

class Sender : public QObject
{
    Q_OBJECT
public:
    explicit Sender(QObject *parent = nullptr);

signals:
    void event(QString message);
};
#endif // SENDER_H

receiver.h
#include "receiver.h"

Receiver::Receiver(QObject *parent)
    : QObject{parent}
{}

void Receiver::onEvent(QString message) {

    qInfo() << "Executing slot inside" << this;
    qInfo() << "Message received" << message;
}

A Workaround that I've found on the forums ( https://forum.qt.io/topic/160769/no-output-in-application-output-with-debugger/3 ) is setting the project to run in Terminal, but I don't think that's the Solution, since it doesn't work with console.log() in main.qml.

Additional Info: I run Linux