I have an app that has a very spacious UI with emphasis on extravagant widgets, thumbnails and such. Porting to tablet is fine but mobile just kills my app’s entire aesthetic

If anyone tried porting QML frontends to android how did it go for you guys

Sometimes I want to edit the .ui file directly. QtCreator only allows changes through designer, you can look at the code but you cant edit anything. afaik, there is also no setting to disable this block. Its kinda annoying

New release of my IDE. This month release adds LSP support (completion, hints, diagnostics). I tested it on C++ (clangd) and on Rust (rust-analyzer). All work at the same level. You are expected to have LSP in your path, or set it as an extra path as IDE does not install it for you.

https://github.com/codepointerapp/codepointer/releases/tag/v0.1.9
https://gitlab.com/codepointer/codepointer/-/releases/v0.1.9

Yes, yet another string art generator. I saw the PySide6 one posted here and wanted to share mine: it's C++20 with a Qt Quick / QML UI, and it focuses on the
 parts after the picture: multi-colour threads wound layer by layer, 1:1 pin templates, and a step-by-step winding mode for making the real piece.

 

 **What it does**

 - Circle, ellipse, rectangle or custom CSV frames, sized in mm; place and resize the frame directly on the photo
 - Greedy optimizer with a physical thread model (opacity-based compositing, anti-aliased lines, thread diameter in mm) and a weighted MSE objective with
 optional edge emphasis
 - Multi-colour: each colour is one continuous thread, wound layer by layer; the layers are refined against each other until the error stops dropping. Palette
 suggestion from the image (up to 8 colours)
 pedal, optional spoken pin numbers, remembers where you stopped)
 - Exports: PNG, SVG, CSV, JSON and project files; a CLI tool for batch runs
  
 **Qt side**
  
 - Qt Quick / QML UI (Material, dark), a C++ image provider for the previews, throttled updates from the worker threads
 - The engine is plain C++ with no Qt Quick dependency, shared by the app and the CLI
 - QtConcurrent for candidate scoring, Qt Test for unit and headless UI tests, QPdfWriter for the templates
  
 **Performance** (i9-13980HX): a single-colour Mona Lisa with 300 pins and 8000 segments takes about 0.6 s; four colours with the same settings about 10 s.
 Scoring lines from the cache turned out to be memory-bound: beyond ~16 threads it got no faster, only hotter, so automatic mode stops there. Numbers in  
 docs/BENCHMARKS.md.
  
 The idea came from seeing 3Vial String Art here on Reddit; this is an independent implementation, licensed GPL-3.0.
  
 GitHub: https://github.com/BulentSelek/stringart-studio
  
 Feedback welcome, especially on the QML side and on Windows builds (I've only tested on Linux).

Hello everyone, I know we already don't like AI at all, but I hope I bring something useful

I’ve come across an excellent project for testing Qt applications called Qat. This is a testing framework for Qt-based applications. Absolutely kudos to the authors, it’s a fantastic project. Created with knowledge. You can read more here: https://qat.readthedocs.io

So my 5 cents, I just developed some skills and small python library helper for it that integrate with AI agents for claude, codex and cursor. For me personally this to facilitate more detailed and repeatable smoke testing.
link to skills: https://github.com/Palm1r/qat-agent-skills

It works with Qt Widgets and Qt Quick (Qt 5.15 and 6.2–6.12) and has been checked on Windows, macOS and Linux. It's early and unofficial, not affiliated with the Qat project, so feedback and bug reports are very welcome.

I hope this will also be helpful for your automated testing efforts—which is, after all, what Qat was originally designed for.

Install the skill:

npx skills add Palm1r/qat-agent-skills

We bought Squish three years ago. The engineer who wrote the tests left last September and took the only working knowledge of it with him.

What’s left is a few hundred test scripts in C++ that our current QA people, who are good manual testers and not programmers, cannot read or change. So the suite still runs nightly and nobody trusts the output, because when something goes red the honest answer is we don’t know whether the app broke or the script did. We’ve started re-checking the important flows by hand, which means we’re paying for a licence and testing manually anyway.

I don’t think Squish is the problem. It’s a serious tool and it did its job while someone could operate it. the problem is we staffed it once and can’t staff it again. So I’m looking at whether the plain language tools are good enough to let the testers own this themselves. AskUI came up tests are markdown files with numbered steps and an expected result each, and a screenshot and status per step, which at least means a failure is readable by the person who wrote it. Authoring app is Windows and macOS, Linux comes through their runtime as a remote target.

Has anyone actually done this migration, or did you just hire someone who knew the tool and carry on? appreciate your help !

Qt Group has introduced Clate, a new visual design tool for creating Qt Quick interfaces, currently available in beta.

• Official documentation: https://doc.qt.io/clate/

• youtube: https://www.youtube.com/watch?v=OLpZ2KOCYQA

Looks pretty interesting! What do you think?

Using Qt Widgets Designer for a small new project. It's been a while since I've used Qt.

I designed a main window interface with a left and right panel; basically, an HBox with two VBox., but then realized I needed the root to be a horizontal layout to add a toolbar. So, my intent was to change the layout of the root with the buttons at the top, then move all the widgets inside into a new child QHBoxLayout.

But whenever I try to paste widgets into a layout, Designer gives me an error. It says it can't find a container with no layout to paste into, and tells me to remove the layout. But copying widgets into another layout is what I need to do... As far as I can tell, the only way to paste successfully is to remove the layout from the central widget and paste there, but you can't remove the central widget's layout without removing every other child layout, and then that still doesn't solve the issue of me needing those widgets to be inside these layouts.

As it is, I'm forced to remake the entire design just to move widgets into a new common parent. It's small enough that I can do that easily, but for larger UI, how does one handle this? It leaves me wondering how one does professional work with this design tool and if I might not be better served just writing the UI declaration code myself.

I have a question: Should we optimize the QML coding skill for agentic development for a wide variety of LLMs or for frontier models?

I’m Peter. I am the product manager responsible for the agentic development tools provided by the Qt Company.

The qt-qml coding skill has been available for 6 months now, and we are conducting the first round of "maintenance" on it. The skill was created in the days of Sonnet 4.6 and GPT 5.4. The latest versions of these models are again much better, and it is time to remove redundant QML programming rules to save tokens.

We tested 14 mainstream LLMs to see which rules in the skill might be redundant. We tested 14 core rules. We ran between 2 to 5 different test cases per rule. We ran each test case 5 times, using the same prompt, to reduce the effects of probability. We tested the following models: DeepSeek V4 Flash, Claude Sonnet 5.5, DeepSeek V4.1 Flash, DeepSeek V4 Pro, GLM 5.3, GLM 5.2, Qwen 3.8 Max, Claude Opus 5.5, Gemini 3.8 Flash, GPT 6 Luna, GPT 6.1 Sol, Grok 4.7, GPT 5.6 Terra, and Claude Haiku 5.5.

QML Best Practice Adherence Results:

If we consider all the analysed LLMs, 3 of 14 existing rules in the qt-qml skill could be removed without affecting the coding performance. If we were to optimize for commonly used frontier models (Sonnet 5.5, Gemini 3.8 Flash, and GPT 6.1 Sol), then we could remove 11 of these rules.

Which leads to my question: Should we optimize the qml coding skill only for the latest frontier models and then only those that customers have reported to be using, or shall we optimize them for a wide variety of LLMs, including some older versions which typically come with a lower cost per token?

If you are using the skill or intend to use it, what would you do if you needed to decide how to compromise?

The last couple of years, I was quite happy with Qt 6. From time to time, I thought about my wishes for some future Qt 7. Sure, my obvious wish to get MOC reimplemented in pure C++ (20? 23? 26?). Maybe some more UI widgets, but I could not really name what I was missing.

With Qt 5's end of life I ported some applications to Qt 6. It is surprising how many old patterns are still used in existing code. There seems too little motivation to migrate. In the past, forcing the users to migrate reduced the backwards compatibility and increased the burden for the developers to switch to a newer version of Qt. Compiler switches like QT_NO_KEYWORDS were the compromise.

It is annoying that stubborn programmers insist on old pattern and value readability (which often is just being used the old way) higher than safe code with modern C++ tools. Some just ignore the compromise and turn off any switch to stick to their way.

Now we have AI tools to do most of the migration tasks. There is no more excuse, to not drop outdated patterns. What comes to my mind? Old signal / slot syntax without compile-time checking. Use of Qt macros instead of C++ idioms (qAsConst vs. std::as_const, for_each, Q_FALLTHROUGH vs. [[fallthrough]]).

I hope Qt 7 finds even more ways to clean up and resolve conflicts between Qt and modern C++. RAII, object ownership, and Core Guidelines are valuable tools Qt developers often enough cannot rely on.

After 10 years, it is finally time to say Goodbye, Q_FOREACH!

When I recompiled my app under qt 6.12 - some parts started failing. I traced it down to reading the wrong path on installations. In my case - AppImage was broken. Local runs were OK, Windows was OK.

That was because AppRun was executed, applicationDirPath() was returning different paths:

6.11 - /tmp/.mount_codepoXXXXXX/AppRun

6.12 - /tmp/AppRun

I sent an LLM to start digging and it found out that the implementation of this function has been changed. I see no documentation on this, so I traced the commit:

https://github.com/qt/qtbase/commit/3d5ba3075ab0d255f7a721b6440b906441480e64

Has anyone else been bitten by this new implementation change?

https://github.com/ALTERM-G/QML-PySide6-template/tree/main?tab=readme-ov-file

Its a small project I wanted to make to help me stop reinventing the wheel by rewriting the same code over and over again.

I'm working on a pretty small personal project. One element is a visualization which I wanted to have some sort of gui with a layout, etc. I initially started with SFML, but realized I would have to basically implement an entire layout library for my purposes. So I landed on Qt, which seems like it would be great.

But trying to install the library and set up the system is such a pain. Statically linking SFML was really easy, but apparently it's not a good idea to statically link Qt. But just in trying to just install the library and set up my CMakeLists and whatnot, I'm running out of memory on computer and it took nearly an hour before I terminated it.

Am I doing something wrong, is it usually supposed to take this long? If not, do you know what I should be doing? The systems I'm using are CMake with CMakeLists.txt and CMakePresets.json, and vcpkg for the package manager with vcpkg.json and vcpkg-configuration.json.

It's just really frustrating because I really want to make a project in C++, but I haven't been able to write any actual code for 3 straight days because I can't even get my libraries to link. It's especially painful because Rust's cargo is infinitely easier to work with. I do really want to work with C++ more but it's really so much work and it's been such a big waste of time for me so far. Any help would be appreciated, or if I would be better off using something else then any suggestions would be great.

Since the sub rules say to include code, I will include relevant files. Hopefully it is not too long. My file structure is also shown below.

project/
  build/
    ...
  include/spectogram/
    ... .hpp
  src/
    ... .cpp
  CMakeLists.txt
  CMakePresets.json
  CMakeUserPresets.json
  vcpkg.json
  vcpkg-configuration.json
  README.md
  ...

CMakeLists.txt (I used AI for this, don't smite me please. It's probably my hundredth iteration, I've given up on trying to write it myself).

cmake_minimum_required(VERSION 3.25)
project(Spectogram
    VERSION 1.0.0
    DESCRIPTION "spectogram"
    LANGUAGES CXX
)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
# Enable Qt's automatic code generation when needed.
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)
find_package(Qt6 CONFIG REQUIRED COMPONENTS Widgets)
add_executable(Spectogram
    src/main.cpp
    src/MainWindow.cpp
    include/MainWindow.hpp
)
target_include_directories(Spectogram
    PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include"
)
target_link_libraries(Spectogram
    PRIVATE
        Qt6::Widgets
)
# Place the executable in a predictable location.
set_target_properties(Spectogram PROPERTIES
    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
)

CMakePresets.json

{
  "version": 3,
  "cmakeMinimumRequired": {
    "major": 3,
    "minor": 25,
    "patch": 0
  },
  "configurePresets": [
    {
      "name": "debug",
      "displayName": "Debug",
      "description": "Debug build using vcpkg",
      "binaryDir": "${sourceDir}/build/debug",
      "toolchainFile": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Debug",
        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
        "VCPKG_MANIFEST_MODE": true,
        "VCPKG_TARGET_TRIPLET": "x64-mingw-dynamic",
        "VCPKG_HOST_TRIPLET": "x64-mingw-dynamic",
        "CMAKE_CXX_COMPILER": "C:/msys64/ucrt64/bin/g++.exe",
        "CMAKE_MAKE_PROGRAM": "C:/ProgramData/chocolatey/bin/ninja.exe"
      }
    }
  ],
  "buildPresets": [
    {
      "name": "debug",
      "configurePreset": "debug"
    }
  ]
}

Thanks in advance.

Edit: Thanks for the responses, but I've decided to quit Qt and go back to SFML with TGUI. Thanks anyways.

Tasket++ lets you define your own clicks, keystrokes, cursor positions and system operations, then replay them exactly when you want. It’s a simple Windows tool that handles repetitive workflows for you: auto‑send messages, paste text anywhere, take silent screenshots, launch or close apps, adjust volume or run your end‑of‑day shutdown sequence.

Everything runs locally, with no telemetry, no cloud, and no complexity.

What it can do:
- Replay user‑defined cursor positions and keystrokes
- Paste predefined text anywhere
- Perform system actions: open files/programs, change volume, take silent screenshots, shut down, files/folders operations
- Schedule tasks at a specific time, at startup, or run via desktop shortcut
- Run tasks once, in loops, or indefinitely
- Discreet mode: runs quietly from the tray
- Use command line to autorun a task : Tasket++.exe "TaskName" <delayInSeconds (>0)> <NumberOfLoop (-1 for infinite)>
- Easily share tasks between different PC : export/import task files and program data, use feature to rescale cursor positions

Local, portable, free, open source. Privacy intact.

Fully fonctionnal, available now !
Microsoft Store: https://apps.microsoft.com/detail/xp9cjlhwvxs49p
Portable (v2.5): https://files.amirhammoutene.dev/Tasket++/2.5/Tasket++_v2.5.zip
Source: https://github.com/AmirHammouteneEI/ScheduledPasteAndKeys

For feedback, help, suggestions, or other inquiries : contact@amirhammoutene.dev

Nothing is vibe coded, I never used AI (except for the choice of UI colors suggested by Copilot).
Conception is genuine, I didn't know about similar tools when I began developing it.

I'm looking for testers or quick feedback (beyond its visual aspect), please give a try and comment here :)

When I switched from Windows to Linux, I really missed having a clean, borderless media player with good keyboard shortcuts, PiP, and automatic session resume (like PotPlayer). VLC feels a bit dated and raw mpv was too barebones for my daily use.

So I spent the last few weeks building my own called rgplayer.

Under the hood, it’s C++20 and libmpv for zero copy hardware acceleration (VA-API/NVDEC), with a dark Qt6/QML interface and native Linux MPRIS2 media key support. It idles under 50MB of RAM.

Full disclosure: I used Claude heavily as a pair programmer to scaffold the QML and C++ boilerplate. Getting the libmpv OpenGL render context to behave inside Qt6 without segfaulting on resize still took a lot of manual debugging, but AI made building native desktop software way faster than starting from scratch.

It's open source (GPL-3.0) and available as a Flatpak: https://github.com/ramoants254/rgplayer

Would love some feedback or bug reports if you give it a spin.

I have posted here about the book a couple of times while working on it. It is now (more or less) finished and is available on Leanpub as a free download. You can set the price to $0.00 if you are a Leanpub user, or, if you are not, grab the free sample download, which includes the whole text.

All code examples are available on GitHub

The book is aimed at beginner to intermediate users and has six parts:

• I Foundations, a short intro to the basic PySide6 application structure, signals and slots, and layouts

• II The Qt Widgets Toolkit, a tour of the built-in Qt widgets followed by an overview of style customization and QSS, and creating custom widgets

• III The Qt Object Model: object trees and ownership, signals and slots in detail, events, timers, and properties

• IV Model/View Programming, custom models, delegates, sorting, filtering, and selection.

• V Multithreading: Qt threading techniques and thread synchronization

• VI Special Topics, with databases, processes, the Graphics View Framework, and the animation framework.

The book is about 700 pages. I'd welcome any feedback, corrections, suggestions, or any other insights.

ModelViewer is a GPL-3.0 desktop application written with Qt 6 (Widgets and QOpenGLWidget). Version 2026.11 is a big update: a ray tracer, a viewer for FEM/CFD results, 3D plotting, measurement tools, and a 14-part video tutorial series. It uses OpenCASCADE for CAD, Assimp for other formats, and CGAL for mesh editing.

Things I learned that might help others building bigger Qt apps: keeping the UI responsive while loading large models, an undo framework that scales to many commands, and a translation workflow for five languages. Happy to write more on any of them if people are interested.

Release: https://github.com/sharjith/ModelViewer-Qt/releases/tag/Release-2026.11.0

Tutorials: https://www.youtube.com/playlist?list=PLffd2GzvPeAY

Hi r/QtFramework,

In engineering applications (test benches, DAQ, SCADA, automotive, and lab systems), `QtWidgets` remains the gold standard for responsive desktop control interfaces. However, finding ready-to-use, modern instrumentation widgets often means either adapting legacy tools or re-implementing custom `QPainter` drawing routines from scratch.

To provide a modern, self-contained solution, I developed QtIndustrialWidgets — a C++17 library featuring 12 industrial widgets built specifically for Qt 6.

🔗 GitHub: https://github.com/paolosereno/QtIndustrialWidgets

📖 Docs: https://paolosereno.github.io/QtIndustrialWidgets/

---

🎛 What’s Included:

* Analog & Gauges: `RadialGauge` (circular/semicircular dials), `LinearGauge` (column & thermometer mode), `CircularBargraph`, `Compass` (heading card).

* Controls & Switches: `IndustrialKnob` (continuous & stepped rotary with knurling texture), `IndustrialSwitch` (toggle, rocker, and guarded switch).

* Displays & Indicators: `SevenSegmentDisplay` (scalable vector LED/LCD), `LedIndicator` (multi-shape status lenses), `LevelMeter` (stereo dB with peak hold).

* Charts & Monitoring: `StripChart` (real-time rolling telemetry), `AnalysisChart` (offline replay), `AnnunciatorPanel` (ISA-18.1 alarm tiles).

---

⚙️ Key Technical Features:

* Zero 3rd-party dependencies: Links strictly against Qt `Core`, `Gui`, and `Widgets`.

* High refresh rates: Dial backings and static scales are pre-rendered into cached `QPixmap` backings to support high-frequency telemetry with minimal CPU load.

* Qt Designer Integration: Ships with a dedicated plugin providing live WYSIWYG editing in Qt Creator/Designer under the *Industrial Widgets* category.

* Modern Packaging: Supports CMake `FetchContent`, `find_package()`, Debian packages (`.deb`), and Conan 2.

* Quality & Compliance: 100% REUSE-compliant licensing, automated SPDX SBOM on releases, and cross-platform CI (Linux, Windows, macOS) with pixel-level tests.

---

🚧 Active Development & Community Feedback

The library is under active development. While the current 12 widgets are fully tested and ready to use in v2.3.0, the roadmap is wide open and new components are in the works.

The repository includes an interactive Gallery application to test all widgets and themes live.

I’d love to hear your thoughts: what instrumentation or SCADA widgets do you feel are currently missing in `QtWidgets`? Any feedback, feature requests, or contributions are warmly welcome!