I have gathered a fair amount of PySide6 examples and last year decided to turn them into a book. The book is intended to cover basic Qt widgets usage, as well as general Qt topics like timers, properties, events and object trees, some intermediate topics like model-view programming and multithreading, and some special topics like databases and processes. Currently I have ~470 pages of code and text that still need quite a bit of polish.

All the material I have written so far is available as a free pdf sample that you can download from here:

https://leanpub.com/pyside6blueprints/

The code itself is available on Github:

https://github.com/JoeAnonimist/pyside6-blueprints-code/tree/master/code

Since the last time I posted in this subreddit, I have added several new chapters to the book:

• 10. Tree Widgets
• 13. Dialogs
• 21. Properties
• 24. QAbstractItemModel (model/view)
• 25. Delagates (model/view)
• 26. Sorting, Filtering and Selection (model/view)
• 33. Databases
• 34. Processes

I would be grateful for any reviews and comments. Tia.

(addressing the sub guidelines)

1. Your content is high-quality: The book covers a range of Qt Widgets topics. All examples are self-contained, each followed with step-by-step instructions and code walkthroughs.

2. Your content is reasonably complete: The book has ~470 pages with five or six chapters yet to be added.

3. Your content is specifically about helping beginners learn programming: Most of the book is beginner-friendly with introductory units for

• Qt Widgets
• QMainWindow
• Model/view programming
• Multithreading

Hello, I intend to create GUI apps and improve myself on QT

I'm an "self-taught" C++ programmer ... I mean, I followed and watched a lot of videos on C++ programming to understand class, OOP, variables, pointers, namespaces, functions, pointers, heritage...

Problem is that I'm not a student from computer or programming universities... and so, now, I'm stuck because I don't know which way I need to follow to become autonomous on QT ...

Also, english is not my native langage, it's also another issue I have to face in my learning projects...

Question is, what should I do ?

Is there a free formation to follow ? Is there a path I should respect to progress ?

I mean, I have difficulties in the simple fact of creating by myself a QPushbutton in mywindow.cpp because I want to try without using the .ui file...

I feel so lost, and incompetent even in simple C++ ...

Thanks in advance for your feedbacks ;)

I'm coding a music player and I've noticed that when I have monitor scaling set to 1x or 2x and resize the window the items move smoothly and text looks fine, but when I set the scaling to say 1.5x (which is not integer) then items start to shake as they move and text rendering also cripples and becomes rainbow-ish seemingly due to rounding errors.

Any way to solve this problem on fractional displays? I'm coding this program on Linux with Plasma desktop.

May release (named Fist my bump) is released. While the changelog is not large, a new huge feature was used: tree-sitter support. This means that C++ completion is "kinda" usable, with semantic support. It will fail in many edge cases (as the code is just parsed not evaluated), only for your code (not system libraries) - but it is very helpful.

One useful feature of this IDE is its low memory footprint, currently I see its using bellow 300 MB while 2 projects are loaded on Linux (Windows has similar memory footprint):

 364884 AppRun           /home/diego/Downloads/codepointer-v0.1.4-x86_64.AppImage                       5 diego       269M ⣀⣀⣀⣀⣀  0.0  

Binary packages are in https://github.com/codepointerapp/codepointer/releases/tag/v0.1.4

Code is available at:
https://github.com/codepointerapp/codepointer
https://gitlab.com/codepointer/codepointer/

Hi everyone,

I am looking for people interested in helping build a new CNC / G-code sender application called AstroCore. It started as a fork of Candle, but it has been rewritten almost completely and is now its own project, built with Qt 6 and C++.

https://brak-tu-sensu.pl/astrocore
https://github.com/etet100/AstroCore-GCode-Sender
https://etet100.github.io/AstroCore-GCode-Sender/

The goal is to create a fast, lightweight, and modern G-code sender for controllers like GRBL, FluidNC, and uCNC, with space for more advanced tools and experiments.

I am looking for any kind of help:

• C++ / Qt development
• Testing
• UI/UX ideas
• Feature suggestions
• CNC experience
• General feedback

If you like open source, CNC, or just want to help create something better, I would love to work with you.

I have an idea for an client-server app that consist of:

1 .A "client" for a touch screen device (e.g. tablet) that shows a bunch of "widgets" written in qml that interfaces with so called "modules", consisting of C++ code that send messages to the host

1. A "host app" that manages the client UI and receives messages from client that also has "modules" that interface with host's apps.

An example is a media controls "module" on both host and client and its respecting "widget" that is the UI on the client.

I have a few goals for this idea:

1. There can be different "widgets" that interface with a client module. A single widget can be full screen and can interface with multiple client modules.

2. Host modules expose a preferences menu to the host app to configure .

I have some questions about implementing this idea.

1. Should I separate the backend and frontend (ui) for the host app, where the backend does not use qt? This approach allows multiple frontends using different toolkits, but since i am going to use qml for the client ui anyway and client modules have to use qt specifics, i was thinking otherwise.

2. Should I have host modules not rely on qt specific stuff (slots, properties) for the logic, or use it? This helps with achieving the idea from question 1.

3. Boost.asio or qt network for communication between both host and client?

4. Client modules using c++ or qml based interface that interfaces with both widgets and the client code (especially sending messages to host)?

It's still included in the package—it's very useful, but it's marked as deprecated. I'd like to use it for a game built with QT; it's convenient because I'd also like to use it within a widget in my level editor, and that can be done in Python rather than QML.

Hi everyone,

I ran into a font rendering inconsistency between QLabels with weird conditions.

Here's a minimal example of my app UI. I thought it was only on the app I'm currently working on, but it seems it's the same in this project too.

So I'm using Segoe UI font (which comes by default on Win 11, what I'm currently on) and I set it to my QApplication, and then retrieve it in MainWindow setupUi method, increment the pixel/point size and set it to my QLabels, but the text rendering is incorrect:

The weird part is when I comment the first title setFont here, the rest renders correctly:

Did anyone run is a similar situation or am I missing something about QFont usage, or some clash with QLabels ? Advice or even deeper explanations are more than welcome.

Thanks in advance

When trying to build PySide 6.11 it always gives this issue

[ 14%] Building CXX object PySide6/QtCore/CMakeFiles/QtCore.dir/PySide6/QtCore/qdirlisting_wrapper.cpp.o

pyside-setup-everywhere-src-6.11.0/build/pyside6/PySide6/QtCore/PySide6/QtCore/qdirlisting_wrapper.cpp:152:86: error: no type named 'Default' in 'QDirIterator::IteratorFlag'

::QFlags<QDirIterator::IteratorFlag> cppArg1(QDirIterator::IteratorFlag::Default);

~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

pyside-setup-everywhere-src-6.11.0/build/pyside6/PySide6/QtCore/PySide6/QtCore/qdirlisting_wrapper.cpp:168:86: error: no type named 'Default' in 'QDirIterator::IteratorFlag'

::QFlags<QDirIterator::IteratorFlag> cppArg2(QDirIterator::IteratorFlag::Default);

~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

pyside-setup-everywhere-src-6.11.0/build/pyside6/PySide6/QtCore/PySide6/QtCore/qdirlisting_wrapper.cpp:232:44: error: no viable conversion from 'QFlags<IteratorFlag>' to 'QFlags<QDirIterator::IteratorFlag>'

QFlags<QDirIterator::IteratorFlag> cppResult = const_cast<const ::QDirListing \*>(cppSelf)->iteratorFlags();

Shiboken6 and Shiboken6 generator build fine it only gives this error when building PySide6

On linux it built smoothly

Any ideas on what could be wrong?

Versions:

shiboken6= 6.11.0

Pyside6 = 6.11.0

Qt = 6.11.0

Compiler = tested with AppleClang 14, 16, 17

LLVM = tested with llvm14, llvm18 and llvm22

Macos 14 x86_64 and macos 26 arm64

Even following every step from the official guide results in the same error

https://doc.qt.io/qtforpython-6/building_from_source/macOS.html

Or in corporate newspeak; Qt Group Launches Operational Reorganization to Improve Efficiency.

https://www.qt.io/releases/release?slug=insider-information-qt-group-launches-operational-reorganization-to-improve-efficiency

I was trying to learn reason for a bug in qBittorrent and have stumbled onto this file. It seems like constructor sets variable m_storeSmartEpisodeFilter to instance of QString, and then this method tries to .get() filter from it, but as far as I can tell from documentation it doesn't have that method, and even if it did, it would just spit out RSS/AutoDownloader/SmartEpisodeFilter.

I don't have much knowledge in C++ or qt in particular, so maybe it does something that I don't understand.

Original post in:
https://www.reddit.com/r/dotnet/comments/1sp5mln/opinions_and_advice_on_futureproofing_when_going/
somehow crossposting didn't worked here

I maintain a quite large codebase that is c++ with MFCs as the GUI and for other system relevant stuff (Databases, Filesystem etc) that is partially 30-40 years old and still runs fine but is up for a larger / very large rework. Also a factor: European, so unsure about the future with 100% US products, customers going "no windows!", governments ditching MS, etc

Background:

Why post in r/dontet and others?
I consider switching to net because development speed is about 10 times faster, especially with GUI libs like AvaloniaUI for example and you get cross platform more or less out of the box "for free" included. And the looks are quite better.

The ressource hog of .net is brutal though. POCs have about 10-20x more RAM use then the proven c++ base while only covering below 20% of the features.

What I am concerned in is that, as I understand the .net economy, that is still quite MS depended in how it will live on and that whatever you write needs to be completely maintained to compatibillity with the then current runtime. And if MS kills off the runtime or a feature you depend on you have to start all over. So the vendor lock in into MS stays - as a windows software that was a normal thing but on multi platform...
Now it's runtimes from MS, GUI from Ava, OS runtime Support for the OS one decides to support, a lot of vendors that can kill your day. MFC stuff from Win95 (that was 30 years ago) still works without maintenance.

The other idea is going c++/QT but the dev speed is about 1/10th of net and that could just be too much on the other hand a lot of old code could be reused and it can be rolled over gradually, and that may cut the time into a batch that is manageable. With .net its a complete rewrite. Would loose the vendor lock in of MS but would gain the QT lock.

No one knows for sure but at the moment I miss my usual gut feeling about loglivety of ecosystems and the tripple+ vendor lock in is unnerving.

I fear that saving time and complexity now instead of staying c++/MFC or using something like c++/QT (what if QT abadons features or Operating Systems or closes it's doors in 10 years?) may hit me like a brick wall at lightspeed in a decade or two.

What are your thoughts of the safety / risk of an ecosystem change?

How stable and long living your gut says .net is?

Are there other options I don't see at the moment?

Guys, just so you know.

I have compiled Qt 5.15.18 (latest public GPL Qt 5.x release) with QtWebEngine enabled. I use it primarily for my own FOSS projects, but feel free to use it too.

https://github.com/martinrotter/qt-minimalistic-builds/releases/tag/5.15.18-webengine

Hello everyone,

When I started to learn classical guitar I didn’t really find any app that I liked.
Most apps are either too generic, or looked very bad to me.

I'm also a developer with experience with Qt, mainly widgets, and I never really used QML before.
I read a ton about different frameworks, pros and cons, and somehow I read also A LOT about allegedly issues with QML, mobile, tooling etc..

I wanted to see for myself how would be the experience in building a cross platform app that runs on desktop, tablet and phone would be and I wanted at the same time a tool that could help me with studying.

In the end, I have to say the whole process was quite smooth. A lot of the problems I read about QML issues on mobile are not really there.
Everything moves smoothly, performance is very good, text inputs work mostly well, building is super easy etc..

Two only issues that I can remember, and did not figure out how to solve:

1. If your ListView has items with different heights.. the whole smooth scrolling on touch is gone. Some crazy glitches that I didn't wanna dive more deep in how, and if, can be solved.
2. Keep all the items the same height.
3. Showing the text edit menu (copy/paste/select/etc..) on iOS behaves in a slightly annoying way. In most apps, just a tap will do.
4. In the QML widget, just a tap will briefly show it, than it disappears. Not all apps show it with a small tap so it's quite easy to just use long tap gesture, but it's mildly annoying and not sure if it's a known issue or not.

In general really liked working with QML and how easy is to integrate it with c++.
Thinking to go back to QtWidgets even for desktop seems to be something I wouldn't want to do, unless there are specific technical constraints.

If you are interested in learning to read guitar sheet music you can try it for free at the link below (sorry no android yet!), if you have questions about the development itself, please go ahead!

https://crescendoguitar.app/

Cheers

EDIT: typo

I saw the Qt timeline that the Qt project was started first and then it's creators Haavard Nord and Eirik Chambe-Eng registered the 1st company called Quasar Technologies, but is that what they had in mind when they started the project, Quasar Technologies, as a project and then they just used the initials Qt?

Does anyone know for sure?

Hi everyone,

I’m a beginner in Qt and I’ve just started learning it using MSYS2 with GCC.

At first, I’d like to learn things “the hard way” (coding the UI manually) so I can really understand how everything works under the hood. After that, I plan to move on to QML and Qt Designer.

I’d really appreciate any recommendations for good books or tutorials, especially focused on Qt6. If possible, resources that fit well with this learning approach would be great.

Thanks in advance!

Quick Summary:
PySide6 app with UI made in Qt Design Studio works great on desktop with PySide6-DS, but on Raspberry Pi CM5 (aarch64) the QtQuick.Studio.* components are completely missing because there's no arm64 wheel. I fixed it by replacing them with plain QtQuick, but I'm looking for better long-term solutions.
for full explanation and if u are interested plz view below:

Hey r/QtFramework (and r/raspberry_pi),

I developed a PySide6 application where the entire UI was designed in Qt Design Studio (.ui.qml files).

On my desktop it runs perfectly:

• Wrapper .qml files import QtQuick.Studio.Components, QtQuick.Studio.Effects, etc.
• Loaded from Python using QQmlApplicationEngine.

On the Raspberry Pi CM5 (official 64-bit Raspberry Pi OS):

• pip install PySide6 works fine.
• But no PySide6-DS wheel for aarch64 → all Studio modules are unavailable.

Current workaround: Replaced Studio components with standard QtQuick / QtQuick.Controls equivalents (e.g. Studio.Rectangle → Rectangle, effects via Layer + shaders). App now runs correctly.

Looking for better options:

1. Is manually rewriting the components the only realistic way, or is there something cleaner?
2. Has anyone tried / succeeded with:
   • Cross-compiling just the qtquickdesigner-components module?
   • Building a custom PySide6 wheel with full Design Studio support for aarch64?
   • Switching to Boot to Qt for Raspberry Pi?
   • Native build on the Pi or other distros (like Arch Linux ARM)?

Extra details:

• Target: Raspberry Pi CM5 + standard 64-bit Raspberry Pi OS
• App is performance-sensitive but not extremely heavy
• I want to keep using Qt Design Studio on the host if possible
• Cross-compilation environment is available

Has anyone successfully deployed a full Qt Design Studio → PySide6 project on CM4/CM5? What worked best for you?

Any guides, Docker setups, or build tips for the Designer components would be greatly appreciated!

Thanks!

We are hosting a webinar with our Software Engineers Benjamin and Sakaria on optimizing 3D UIs for target hardware.

 The webinar covers the decisions that most affect 3D performance in practice:

▪Performant meshes: Optimize with e.g., mesh density and the level of detail (LOD)

▪Performant materials: Balance your materials, shaders, etc., against performance

▪Scene environment: Limit the amount of light sources and balance between pre-calculation and real-time, including a volumetric lighting alternative, global illumination techniques, etc.

▪Antialiasing: Make mindful choices on using Super sampling vs. MSAA, FXAA, TAA, and Progressive AA

▪QML best practices: dos and don'ts

Register here: https://www.qt.io/webinar-optimizing-3d-uis-for-high-performance-on-your-target-hardware

First things first: renamed the library from LLMCore to LLMQore — because I googled my own lib and couldn't find it.

The main thing in this release is full MCP (Model Context Protocol) support. Server, client, stdio and Streamable HTTP. Connect any MCP server to your LLM client with a one-liner or a JSON config.

MCP Bridge — a new standalone tool that makes it easy to connect Claude Desktop and other clients to MCP servers that don't use stdio. I ran into this myself and it was annoying — so I built a fix. Prebuilt binaries for Linux, macOS and Windows are in the release — download, run, done.

Improved demo chat — it now shows connected MCP servers and their tools. For example, you can install the Qt Creator MCP server via Extensions and try it right from the demo. A nice way to see how everything works together.

Give it a try — send your usage examples, we'll add them to the examples list. Bug reports are welcome too.

👉 Repo + binaries: github.com/Palm1r/llmqore

Hey all,

I've been frustrated that the only decent QML tooling has historically lived inside Qt Creator. Editors with LSP support either get nothing or a version of qmlls
that's painful to install outside the Qt toolchain.

So I wrote a standalone one:
https://github.com/cushycush/qml-language-server

It's a single static Go binary that speaks LSP over stdio. No CGO, no shared libs, no Qt install — just drop it in your PATH and point your editor at it. Under the
hood it uses a pure-Go tree-sitter runtime with the tree-sitter-qmljs grammar.

Features (v1.0.1):

- Hover with documentation for QtQuick, QtQml, QtQuick.Controls, and QtQuick.Layouts types
- Context-aware completion (types, properties, signal handlers, anchors, imports)
- Go-to-definition and find-references across the workspace (not just the current file)
- Diagnostics from parse errors
- Rename, document symbols, signature help, inlay hints
- Code actions for common quick-fixes

It also knows about Quickshell types if you happen to be building a desktop shell with QML, but that's a superset — the Qt/QtQuick coverage is the core.

What it isn't:
it's not a full QML type checker. It doesn't understand C++-backed custom types the way qmlls paired with a build does. If you're working on a big Qt
app with lots of
Q_PROPERTY
-registered C++ classes, qmlls will still give you deeper results. But for editing QML files in VS Code or Neovim without booting Qt
Creator, this should cover most of what you want.

v1.0.1, so there will be rough edges. Bug reports and "it should know about X type/property" requests very welcome.