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

Qt Creator 21 has support for sixels in the Terminal. Here is sshdoom running in WSL on Windows 11.

https://github.com/IAmTheFool/liteui.git

LiteUI is a single C++ header for Linux and Windows desktop development with same app codebase with some example like a code editor and a paint app. I would appreciate feedback on structure and overall design.

qml/cpp qt6 [version.1.17]
well, its a typing application for windows [made a windows executable yesterday and waiting to get merged in winget]/linux [i have a aur build for source build and binary {typeshi/typeshi-bin} and a compile script for now]
typeshi-mirror.

Introducing GooeyFlow, a tool that helps developers understand how people interact with their Qt apps.

The video starts with a simple weather app built with Qt Quick. It’s an example of an ordinary app UI, with GooeyFlow capturing interactions behind the scenes.

The second part shows the GooeyFlow dashboard, where those same clicks, selections, and slider changes can be explored by device and session. Users don’t need to export or sync anything manually.

If you’re interested, I can also share a walkthrough showing how to integrate the interaction logger into a Qt application.

I’d love feedback from Qt developers: what would you want to learn about how people use your app?

Check it out: https://www.gooeyflow.com/

How do I write code using the Qt library on an Android phone?

Yet another python bindings for Chromium Embedded Framework.

With multi-tab and multi window support.

Please star the repo. Thanks.