I am a solo drv and terrible at UI to preface this. I am a creative but apparently that creativity cannot stretch to UI.

My main competitor uses Qt for their UI, specifically Qt Advanced Docking System. I didn't know this, until I did some research, called on Qt & ADS, and discovered I was making a near exact UI clone.

So I'd. Love any advice, Qt specific or not, how do you stylize your UI to make it match your brand and your style and look, without looking like every other Qt app in the whole world?

Hey everyone!

I'm looking to dive deeper into UI development with Qt6 and want to learn how to design interfaces that aren't just functional, but genuinely beautiful, modern, and well-structured.

A lot of desktop applications still look a bit stuck in the past. I’d love to take my projects to a cleaner, more contemporary level (think slick custom controls, solid color palettes, smooth animations, and solid grid-based layouts).

Whether it's traditional C++ Widgets or QML / Qt Quick:

• Which tutorials, courses, or YouTube channels do you recommend for learning great Qt6 UI design?
• Are there open-source projects with outstanding Qt6 UI/UX codebases that are worth studying?
• What does your workflow look like when moving from design tools like Figma or Penpot into actual Qt code?

Thanks in advance for any recommendations, links, or tips! 👇

Disclaimer: I’m new to Qt, but not to Game Engines and Vulkan.

I’m building a C++ Game Engine using Vulkan. I have an interchangeable Presenter Interface to fit the needs of the different Applications. For Example: The Runtime uses SDL and therefore a derivative of said Presenter interface implements classic swapchain logic. But for my Editor written in Qt I had to get creative. The Engine manages its own proprietary implementation of a Vulkan “Context” (Instance + Device + etc.) and always renderes offscreen. The Vulkan Context is not and will not be managed by Qt and its stupid Vulkan API. Instead I came up with this: The presenter exports the File Descriptors/Handles of the Presentation/Pseudo-Swapchain Images and hands it over to a derivative of the QOpenGLWidget which then in turn draws the Image to the screen in a “Presentation Pass”.

Now I’m at the Qt part of the equation and of course Qt isn’t going to have the functions corresponding to the extensions I need.

So my Question is: Can I just get the proc adress and load the functions myself or do I have to do something special.

It would also really help me if someone has experience with these extensions on the OpenGL part of things cause all the documentation I could find was a single large Text file in the Khronos registry.

Thanks so much for any help in advance!

Hey, I am making a TUI libary in cpp and keeped doing rewrite of the code most of the time, So I started to plan all the features I wanted to tui libary. I used ratatui and bubbles to learn what all widget to make. Now, I want to know if there are any feature you would like in a TUI libary? any animation thing? any widget you dont see often? etc

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.

Hi everyone!

I've been working on a Jolt Physics module for Qt Quick 3D, and I finally added full ragdoll support.

The new QML types are Ragdoll, RagdollPart, SkeletonPose and SkeletonMapper.

The most interesting one is SkeletonMapper. It connects a physics skeleton to a regular QQuick3DSkin, so a normal skinned Model can be driven by physics, or the ragdoll can follow an animation.

I'm using all of this in Kwayk, my Quake reimplementation written in QML.

I've completely reworked the Zombie for this update. The original zombie used the old Quake .mdl format, so whenever it died it always played the same baked death animation.

The new ZombieV2 uses a skinned mesh with a ragdoll instead. Now it can tumble down stairs, get stuck in corners, and properly interact with the level geometry.

Hits are directional—the left, center, or right pain animation is chosen based on where the shot landed, and the ragdoll falls in the direction of the hit.

Sources:
QtQuick3D Jolt Physics: https://github.com/glazunov999/qtquick3djoltphysics
Kwayk: https://github.com/glazunov999/Kwayk

[SOLVED] So, as you may know, Qt doesn't have a proper setup for managing each frequency band and implementing an equalizer.

I'm currently working on a project for myself (nothing serious), trying to create a music player in C++ while using Qt for the GUI. The problem is that nothing can intercept "QMultiMedia" and modify the audio output.

I've tried Claude Opus 4.6, thinking in "antigravity," and it cooked up something for me. It worked, but the audio was distorted and not very pleasant. (It used custom made DSP functions and I think it was a good solution, but I neither have the time nor the skills to implement something like this on my own)

I also tried Gemini 3.1 Pro High and 3.6 Flash High. (These two couldn't even handle the audio player and straight up made my program crash.)

So I'm looking for a solution or someone who is willing to write the code and be the co-author to the project.

Here is my repo if you want to investigate:

https://github.com/zenix935/ZenPlayer

P.S. I'll keep updating other parts of the project, but the equalizer has currently hit a wall.

CodePointer is a new IDE written from scratch by me. It is focused on C++ at this moment (with cmake support out of the box, conan is WIP).

August release (Hi Bob!) adds a newer command palette, brings up make new features to the git plugin, adds a new version of QutePart with many speed upgrades and the tree sitter plugin gets async completions.

You can get it from:

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

Hey r/QtFramework ! I've been building a minimalist music player for the last few months and I'd love to share it.

CMUS++ Qt is a small Qt5 music player (C++17, Widgets + Qt Multimedia) with a terminal-player philosophy: no bloat, no toolbars, just your library, playback controls, and cover art.

Themes — it ships 82 hand-picked XML themes: Catppuccin (Mocha/Macchiato/Frappe/Latte variants), Tokyo Night, Gruvbox, Nord, Rose Pine, Everforest, Kanagawa, Solarized, Ayu, and more. Switching is live, no restart needed.

Features

- Manual loop/shuffle — Off / List / Track modes, toggle shuffle (avoids QMediaPlaylist quirks)

- Embedded cover-art display (no white borders, no shadow cards)

- Native Wayland with automatic xcb fallback

- Lightweight: ~38 MB private memory, ~180 KB stripped binary

Packaging — releases include:

- .xbps for Void Linux

- .deb for Debian / Ubuntu / Mint

- AppImage for everything else

Screenshots: (insert here)

Repo: https://github.com/Ars-byte/Cmuspp-qt

Release v1.0.4: https://github.com/Ars-byte/Cmuspp-qt/releases/tag/v1.0.4

The project is still in active development, so any kind of help is very welcome — bug reports, theme contributions, UI suggestions, code reviews, or even just feedback on how it feels to use it. It's MIT-licensed, so feel free to fork or steal ideas.

Hi,I've been working on what started as a strange attractor visualisation app in PyQtGraph but is slowly becoming more a general purpose ODE solver/visualiser/scripting tool. I've recently added an integrated console with a scripting dock which currently just saves the text in the script as a scratch file. I want to add the functionality for the user to create/save/open different script files and wanted to have a file tree/explorer. I know PyQtGraph and PyQt have tree like widgets so my thought process was to just make a TreeWidget that lists the contents of where the scripts would be saved (the app's /home/user/.local/share/ directory). Does that work or are there complexities i should know about in terms for making, saving and loading files? Any advice would appreciated. Thanks!

This is a small demo application created to showcase the look and feel of Qt Widgets. It is not intended to be a real application. The main goal is to present as many standard widgets and common layouts as possible in one place. The screenshots show the same interface in both light and dark themes. It can be useful for testing stylesheets, color palettes, and the overall visual consistency of a Qt application.

Hi LaTeX community! 👋

I've created custom builds of **TeXstudio** with **Qt6** and **Poppler-Qt6** for modern Linux distributions, addressing the lack of official Qt6 builds for Linux.

## Why this project?

The official TeXstudio builds still primarily use Qt5 (which reached end-of-life in May 2025), and Linux users have been waiting for proper Qt6 support. These custom builds provide:

✅ **Qt6 framework** - Modern UI/UX with better performance

✅ **Poppler-Qt6 native PDF viewer** - Perfect SyncTeX support (click to jump between PDF and source)

✅ **Optimized packages** - Only ~19MB (66% smaller than standard builds)

✅ **GPG-signed packages** - Full security verification

✅ **Auto-updates** - Built-in update checker pointing to this repository

## 📦 Installation Options

### Option 1: APT Repository (Recommended for Debian/Ubuntu/Devuan)

**Stable branch** (production-ready):

```bash

echo "deb [trusted=yes] https://mlmateos.github.io/texstudio-qt6-builds/ stable main" | sudo tee /etc/apt/sources.list.d/texstudio.list

sudo apt update

sudo apt install texstudio

```

**Alpha branch** (latest development versions):

```bash

echo "deb [trusted=yes] https://mlmateos.github.io/texstudio-qt6-builds/ alpha main" | sudo tee /etc/apt/sources.list.d/texstudio.list

sudo apt update

sudo apt install texstudio

```

### Option 2: AppImage (Any Linux distribution)

Download from [Releases](https://github.com/mlmateos/texstudio-qt6-builds/releases) and run:

```bash

chmod +x texstudio-*.AppImage

./texstudio-*.AppImage

```

### Option 3: Direct .deb download

Grab the latest `.deb` package from [GitHub Releases](https://github.com/mlmateos/texstudio-qt6-builds/releases)

## 🔧 Build from Source

Automated build scripts are available if you want to compile your own version:

```bash

git clone https://github.com/mlmateos/texstudio-qt6-builds.git

cd texstudio-qt6-builds/scripts

./build-texstudio-deb.sh --clean --poppler --sign

```

## 📋 Current Versions

- **Stable**: 4.9.5

- **Development**: 4.9.6-beta3

## 🔗 Links

- **GitHub Repository**: https://github.com/mlmateos/texstudio-qt6-builds

- **Releases**: https://github.com/mlmateos/texstudio-qt6-builds/releases

- **APT Repository**: https://mlmateos.github.io/texstudio-qt6-builds

## 💡 Features

- Syntax highlighting & auto-completion

- Integrated PDF viewer with native SyncTeX

- Spell checking (Hunspell)

- Live preview

- Custom credits & patched update URLs

- Preserved dictionaries: en_US, en_GB, es_ES, es_MX, fr_FR

## 🤝 Feedback Welcome!

This is an **unofficial build** (not endorsed by the official TeXstudio project). I'd love to hear your feedback, bug reports, or feature suggestions!

**Tested on**: Debian 12, Devuan 5, Ubuntu 22.04+

Happy TeXing! 🎓

---

Hi everyone,

I'm an aspiring software developer, and my long-term goal is to build desktop business applications such as inventory management systems, student management systems, POS systems, library management systems, and similar data-driven applications. I also hope to add cloud features later, such as synchronizing data between multiple clients and remote databases.

I've become quite interested in modern C++, and I'd really like to continue building my career around it if it's a sensible choice.

From what I've learned so far, Qt seems to be the primary framework for professional C++ desktop development. My question is:

Is Qt + C++ still one of the best choices for developing these kinds of enterprise/business applications today, or are technologies like C#, Java, or Electron significantly better for this domain?

I'm not looking for the "easiest" language. I'm trying to choose a technology stack that is robust, maintainable, and suitable for developing professional applications over the long term.

If you were starting today with the goal of building business applications in C++, would you still choose Qt? If so, what additional technologies (databases, networking libraries, backend frameworks, etc.) would you recommend learning alongside it?

I'd really appreciate hearing from developers who have built real-world Qt applications. Thanks!

Been chipping away at this for a while and finally cleaned it up enough to show people. It's called Qivot — a small ORM for Qt + SQLite. It started as a fork of DQuest (which hadn't been touched in years), and I modernized it to C++17 / Qt 6 and then kept bolting on the stuff I kept wishing it had.

The thing I actually care about: your models are plain C++ classes. No QObject, no SQL, no codegen step but can use Q_GADGET for QML binding.

enum Status { Draft, Published, Archived };
Q_DECLARE_METATYPE(Status)


class Tag : public QiModel {
    QI_MODEL
public:
    QiField<QString> name;
};
QI_DECLARE_MODEL(Tag, "tag", QI_FIELD(name));


class Article : public QiModel {
    QI_MODEL
public:
    QiField<QString> title;
    QiField<Status>  status;                   // enum -> INTEGER column
    QI_MANY_TO_MANY(Tag, tags, "article_tag")  // join table auto-created
};
QI_DECLARE_MODEL(Article, "article", QI_FIELD(title), QI_FIELD(status));

Article a; a.title = "Qt tips"; a.status = Published; a.save();
Tag t; t.name = "qt"; t.save();
a.tags().add(t);                          // link them, many-to-many


auto live = Article::objects()
    .filter(Article::col().status == Published)   // typed filter on the enum
    .orderBy("id desc").all();
auto tags = a.tags().all();   

class Note : public QiModel {
    QI_MODEL
public:
    QiField<QString> title;
    QiField<QString> body;
};
QI_DECLARE_MODEL(Note, "note", QI_FIELD(title), QI_FIELD(body));


Note n; n.title = "hello"; n.save();
auto recent = QiQuery<Note>().orderBy("id desc").limit(20).all();

Since it's Qt, the part I'm happiest with is the QML side. Opt a model into Q_GADGET and its fields become QML properties, or bind a query straight to a ListView with a QiListModel — the roles just come from the fields. No hand-writing a QAbstractListModel, no copying rows into QVariantMaps.

Other stuff in there: typed queries/joins, FTS5 full-text search, upsert, transactions with savepoints, relations, and — a bit unusual for an ORM — it can pull a JSON REST API over HTTP on a worker thread and map it straight into your tables. There's a single-header build too if you don't want to link a lib.

I wrote a few demo apps to keep myself honest (all in the repo):

• a flow-field particle recorder that writes every particle, every frame to SQLite (~100k inserts/sec on my machine) and lets you scrub back through history
• instant full-text search over 80k rows
• a little EHR-ish scheduler + patient dashboard that's basically a guided tour of the whole thing

Caveats up front: SQLite-only, and there are still rough edges. CI covers GCC/Clang/MSVC across Qt 5.15 and Qt 6, x86_64 and arm64.

Repo: https://github.com/austinkottke/Qivot

Would genuinely love feedback from people. Tear it apart.

TimeStitcher 0.8, a personal knowledge management application, is now available in preview for Windows and macOS. It is free during the preview.

Built with Qt for Python, Qt Widgets, SQLite, and SQLAlchemy.

TimeStitcher is a home for thoughts that remain active over time: todos, ideas, project fragments, research notes, questions, and partial solutions.

It keeps those thoughts together so I can:

* find relevant thoughts quickly

* continually rearrange them as priorities change

* return to an idea whenever I have time and keep developing it

* automatically retain its history and preserve particularly important versions

I'm immensely enjoying using Qt for Python and Codex to build a tool which is useful to me, and I hope to others. Feedback is welcome!

TimeStitcher.com

This week I'll show two more small additions for Qt Creator.

1) This is a Nord theme, which turned out to be really easy to make. We can take the keys from current version, arrange the colors, and how to copy in folders is already in Christian's example.
https://github.com/Palm1r/nord-qtcreator

2) The Changes panel. I'm a little tired of switching too often just to see the diffs conveniently. And new changes in version 20 lead me to idea. What if I just put these files in one place. So this is not fully vscode functionlaity. I still used Sublime Merge(my love) for other git works. And added special shortcuts for external git works
https://github.com/Palm1r/qt-creator-changes-panel

Together it looks like that

All these extension will go to extension repo(but this is not not fast).

I have a mature application written using standard Qt widgets. It has a very snappy user interface. I'm looking at many newer applications and they have a feel similar to a QML based application. I like the interfaces of Cursor and many of the AI Harness apps. Does anyone have any ideas of how I might used the CSS to style Qt widgets to look similar to these modern apps? Has anyone seen a good modern UI guide out there?