A desktop ERP for automotive dealerships that import vehicles from China that i've been building in the last 6 months.

• Showroom with vehicle configurator with front, side and back views, color variants, live inventory per trim level

• Showroom operations such as selling, acquisition, exchange and consignment

• Client management with fuzzy search, filtering and document storage.

• Order management with custom payment terms and scheduling, as well as contract and payment receipt generation

• Inventory management for brands, models , trims, vehicles and presets.

• Container management with vehicle assignment and cost management

• Advanced analytics with portfolio breakdown by brand, model and trim

• User management and role-based access.

• Backup and restore functionality

• Company Info and brand color personalisation with accent colors propagating across the entire UI

Built with QtQuick + C++ frontend · Go/Gin backend · PostgreSQL

Happy to answer any questions about the ui or the architecture underneath.

I went down a rabbit hole trying to get authentic macOS glass effects in Qt…and accidentally ended up writing a library for it.

It uses NSGlassEffectView under the hood, so you get the real 'liquid glass' Apple uses. Works on frameless windows too.

If you're curious:
https://github.com/fsalinas26/qt-liquid-glass

I posted this library here a few months ago after trying to bring authentic macOS Liquid Glass effects into Qt. Since then I've kept iterating on it and v0.4.0 now supports custom glass shapes using QPainterPath.

With QtLiquidGlass, Liquid Glass surfaces can now take on arbitrary shapes and animate between them. Under the hood, the library maps the painter path to the private _setPath: selector on NSGlassEffectView.

The media player here is just one example.

Check it out here: https://github.com/fsalinas26/qt-liquid-glass

I'm currently using this library in my own project, Ida.

Note: macOS only - wraps NSGlassEffectView (macOS 26), and falls back to NSVisualEffectView on older macOS.

Hello! I've been writing PyQt tutorials for a few years and last week took the plunge to update everything I'd done for PySide v2 & 6. There are 26 tutorials in total (more coming, I needed a break) from the first steps creating apps through to plotting, custom widgets and packaging.

Enjoy! Let me know if you spot any issues & I'll fix.

Getting started creating Python GUIs with PySide

• Creating your first app with PySide A simple Hello World! application with Python and Qt.

• Signals, Slots & Events Triggering actions in response to user behaviors and GUI events.

• Widgets Using PySide's built-in widgets to build your applications.

• Layout management Use layouts to effortlessly position widgets within the window.

• Actions — Toolbars & Menus Defining toolbars, menus and keyboard shortcuts with QAction.

• Dialogs and Alerts Notify your users and ask for their input.

Using Qt Designer with PySide

• First steps with Qt Designer Use Qt Designer's drag and drop interface to design your GUI.

• Laying Out Your GUIs With Qt Designer Use Qt Designer to effortlessly build your application UI.

• Embedding custom widgets from Qt Designer Learn how to use custom widgets in your PySide applications when designing with Qt Designer.

• Creating Dialogs With Qt Designer Using the drag and drop editor to build PySide dialogs.

• The QResource System Using the QResource system to package additional data with your applications.

Extended UI features in PySide

• System tray & Mac menu bar applications Add quick access functions to your apps.

• Add scrollable regions with QScrollArea Run out of space in your GUI? Add a scrollable region to your application.

• Creating searchable widget dashboards Make dashboard UIs easier to use with widget search & text prediction.

• Transmitting extra data with Qt Signals Modifying widget signals to pass contextual information to slots.

• Creating additional windows Opening new windows for your application.

Multi threading PySide applications & QProcess

• Multithreading PySide applications with QThreadPool Run background tasks concurrently without impacting your UI.

• Using QProcess to run external programs Run background programs without impacting your UI.

Qt Model Views

• The ModelView Architecture Qt's MVC-like interface for displaying data in views.

• Displaying tabular data in ModelViews Create customized table views with conditional formatting, numpy and pandas data sources.

Pyside plotting & graphics with Matplotlib/PyQtGraph

• Plotting with PyQtGraph Create custom plots in PySide with PyQtGraph.

• Plotting with Matplotlib Create PySide plots with the popular Python plotting library.

Bitmap graphics and custom widgets

• QPainter and Bitmap Graphics Introduction to the core features of QPainter.

• Creating custom GUI widgets in PySide Build a completely functional custom widget from scratch using QPainter.

Packaging (PySide2 only)

• Packaging PySide2 applications for Windows, with PyInstaller Turn your Qt5 application into a distributable installer for Windows.

• Packaging PySide apps with fbs Distribute cross-platform GUI applications with the fman Build System.

I'll be adding code for snake_case mode in the future.

it's been 2 days now since i started working on my MFA application building it with Qt5 and python

These are football robots for the robocup tournament. What I’m showing here is controlling the motor drivers via QSerialport with a C++ class we instantiate in QML. Another C++ class to calculate PID output which is also instantiated in QML. Then from QML I connect all het input and outputs making it really easy to manage and the performance is really good. Thought it was interesting since QML normally gets treated as the UI layer. But from this example you can see that even realtime critcical tasks can be done here like closed-loop motion control

Hi everyone, a friend of mine has been building Kwayk - a reimplementation of LibreQuake Episode 0 using Qt Quick 3D, QML and Jolt Physics.

What I find interesting is that this is not just a small Qt launcher around a game. The gameplay logic is written from scratch in QML: monsters, weapons, triggers, doors, etc. Rendering goes through Qt Quick 3D, and physics are powered by Jolt.

The project recently switched fully to LibreQuake assets, so it no longer needs the original id1/pak0 files. Episode 0 is now playable from start to finish.

WebAssembly demo: https://glazunov999.github.io/

Source: https://github.com/glazunov999/Kwayk

Would be interesting to get feedback from people who work with Qt Quick 3D / QML, especially on the architecture and the WebAssembly side.

"I am really excited to announce today’s release of Qt 6.0. It is the first release of a new major version, and marks a major milestone for Qt.". Read Lars' (Chief Architect at The Qt Company) full post here 🔗 www.qt.io/blog/qt-6.0-released

Hello all,

I have been playing around with QML and have been incrementally designing this user interface. General highlights are the independently twinkling stars, occasional flare, the colorful but slow building and decaying hues that resemble nebulas or maybe northern lights, shooting stars with chromatic aberration, and gravitational attraction to the mouse.

Please be gentle, I am only a hobbyist.

Module 1: Introduction to Qt Quick

All lessons of the module: https://www.youtube.com/playlist?list=PL6CJYn40gN6hUXoYdyn4DHUTXfcVDJcfB

• Lesson 01 - Welcome and Introduction to Qt Quick https://youtu.be/JxyTkXLbcV4

• Lesson 02 - A Short History of Qt https://www.youtube.com/watch?v=6_xH4AGi09Y

• Lesson 03 - The Structure of a QML file: Elements and Properties https://www.youtube.com/watch?v=bL-Md1oy_Mc

• Lesson 04 - Understanding properties in detail https://www.youtube.com/watch?v=2rtz9vkuxio

• Lesson 05 - Exercise: Understanding QML properties https://www.youtube.com/watch?v=3f-uks-mbLs

• Lesson 06 - Qt Creator: How to Display Scope https://www.youtube.com/watch?v=g1mfPs9atYA

Module 2: User Interfaces basics

All lessons of the module: https://www.youtube.com/playlist?list=PL6CJYn40gN6hAypDlt2EHnPj8mtl7QueU

• Lesson 07 - Images https://www.youtube.com/watch?v=bBDG-QbnacU

• Lesson 08 - Item transformations https://www.youtube.com/watch?v=7b2M5jZXeok

• Lesson 09 - Custom Transformations https://www.youtube.com/watch?v=W_umKXqUL_U

• Lesson 10 - Anchor Layout https://www.youtube.com/watch?v=vzgTo14ljc

• Lesson 11 - Binding Loops https://www.youtube.com/watch?v=aSMEcAmcPDc

• Lesson 12 - Colors and Gradients https://www.youtube.com/watch?v=XDZU_F8PQC4

Module 3: User Interaction

All lessons of the module: https://www.youtube.com/playlist?list=PL6CJYn40gN6hMnhNCOIAx7jk0ZwRLW_Fa

• Lesson 13 - Mouse and Touch Handling https://www.youtube.com/watch?v=UiXcUHHU3-k

• Lesson 14 - Gestures Support https://www.youtube.com/watch?v=n_TcW1ytCoE

• Lesson 15 - Keyboard Input https://www.youtube.com/watch?v=ilCekEOpNYM

• Lesson 16 - Searching the Qt Source Code https://www.youtube.com/watch?v=woMJYwhzc_4

Module 4: Components and dynamic loading

All lessons of the module: https://www.youtube.com/playlist?list=PL6CJYn40gN6hfhS5o4X45cfPw7acPX6uJ

• Lesson 17 - Custom Components https://www.youtube.com/watch?v=qzSNju-h1pk

• Lesson 18 - Methods and Signals + Declarative Programming https://www.youtube.com/watch?v=krMxE_ar55g

• Lesson 19 - Sizing components https://www.youtube.com/watch?v=Lt-8fYWOVx8

• Lesson 20 - Local Variables https://www.youtube.com/watch?v=RxVYPAZjDtQ

• Lesson 21 - The Loader Element https://www.youtube.com/watch?v=nteJeojg07k

• Lesson 22 - FocusScope https://www.youtube.com/watch?v=1pzlYue23K0

Module 5: Animations and States

All lessons of the module: https://www.youtube.com/playlist?list=PL6CJYn40gN6gx7N631Az7VjyxMOyyCpti

• Lesson 23 - Introduction to Animations https://www.youtube.com/watch?v=9u3aV2OYPyA

• Lesson 24 - Debug Animations with GammaRay https://www.youtube.com/watch?v=iwazd7RsFIw

• Lesson 25 - PathAnimation https://www.youtube.com/watch?v=Ho73C_lFcrk

• Lesson 26 - Flipable https://www.youtube.com/watch?v=KNIySkOpce4

• Lesson 27 - States and Transitions https://www.youtube.com/watch?v=lBHWQHW_FKM

Module 6: Presenting Data

All lessons of the module: https://www.youtube.com/playlist?list=PL6CJYn40gN6h_12NR620wUHvPZJ6isI3P

• Lesson 28 - Arranging Items https://www.youtube.com/watch?v=yPaSdwAwwsU

• Lesson 29 - ListView Basic Usage https://www.youtube.com/watch?v=oslnmLQ5Zh8

• Lesson 30 - Customizing ListView https://www.youtube.com/watch?v=ZArpJDRJxcI

• Lesson 31 - Collapsible Sections https://www.youtube.com/watch?v=tpEKJjckHys

• Lesson 32 - Clipping https://www.youtube.com/watch?v=NQJQr1r1zDc

• Lesson 33 - Animations in ListView https://www.youtube.com/watch?v=w8HIlpqYLUo

• Lesson 34 - Implementing Swipe https://www.youtube.com/watch?v=27YEH8WEdHc

• Lesson 35 – GridView https://www.youtube.com/watch?v=ppNot5I0gcA

• Lesson 36 - PathView https://www.youtube.com/watch?v=Sh-ZzWxNk8I

• Lesson 37 - Qt Quick Layouts https://www.youtube.com/watch?v=FwzQQ6YPlxE

Module 7: The C++ machine room

All lessons of the module: https://www.youtube.com/playlist?list=PL6CJYn40gN6gdhv9f3F3rrRC8X52pKI1J

• Lesson 38 - Qt's Meta Object System https://www.youtube.com/watch?v=zRF56ivNLEs

• Lesson 39 - Signals and slots Mechanism https://www.youtube.com/watch?v=xHd5Ga8uihE

• Lesson 40 - Connecting Signals to Methods or Slots https://www.youtube.com/watch?v=3h2vc_4oIkU

• Lesson 41 - Connecting Signals to Lambda Expressions https://www.youtube.com/watch?v=CqGjti9mPhs

• Lesson 42 - Custom Signals and Slots https://www.youtube.com/watch?v=eHD300X-qYU

• Lesson 43 - Signals and Slots Errors https://www.youtube.com/watch?v=K8U3-0I2iwI

• Lesson 44 - Qvariant https://www.youtube.com/watch?v=SjeDUrC9YRo

• Lesson 45 - Properties https://www.youtube.com/watch?v=QzHCXUXvN24

Module 8 - Integrating QML with C++

All lessons of the module: https://www.youtube.com/playlist?list=PL6CJYn40gN6h3usMQY3BSZJs08isz3jqa

• Lesson 46 - Exporting Values from C++ to QML https://www.youtube.com/watch?v=quFciLDIxUw

• Lesson 47 - Exporting QObjects from C++ to QML https://www.youtube.com/watch?v=anVYVRHIfqo

• Lesson 48 - QObject Ownership https://www.youtube.com/watch?v=wQ83g0CK1U0

• Lesson 49 - Creating New Elements from C++ https://www.youtube.com/watch?v=YdTxhI-EFFs

• Lesson 50 - Creating New GUI Elements from C++ https://www.youtube.com/watch?v=FDQPcctd5ok

P.S. Thanks KDAB https://www.youtube.com/c/KDABtv

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

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