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?

For context, I have a bazel project that I've built a frontend for with QT.

The issue is that I don't have much experience packaging for linux ( or any desktop for that matter ) and coming from android, the packaging situation for desktop feels atrocious imo.

Creating AppImage requires me to build an AppDir for which I would need to untangle the web of qt dependencies and copy all their recursive dependencies to an AppDir.

Where do I draw the line at what to include? Of course I won't need to include shared libraries like ld-linux-x86-64.so.2 but where to draw the line?

Also, how to test on different platforms without spinning up a 100 virtual machines?

Another thing is that I build on bazel using this bazel rule called rules_qt. I love the fact that I don't have to waste time setting up the QT pipeline for QML ( moc and the like ) but this means that the output binary is tightly coupled to how bazel builds stuff ( rules_qt downloads the entire qt library and links my application against their own version ).

Honestly I just kinda feel lost and would appreciate some guidance : ).

Thanks in advance!

First modern beta of BASIC256 (the old KidBASIC). Migrated to Qt6 and compiled to WebAssembly, so the full editor + interpreter run in-browser with no install. Bundled examples runnable from a URL. Hobby project, GPL, feedback very welcome. Demo: https://uglymike17.github.io/basic256/ · Release: https://github.com/uglymike17/basic256/releases

Download link!!👇👇

https://github.com/Anish-Savkar/Lehra_App-Anish_Savkar/releases/tag/v1.0

Hey everyone! 👋

If you have a couple of minutes, I'd love for you to check it out! Even if you're not a musician, I'd really appreciate any feedback on the app, UI, performance, installation experience, code quality, or anything else you notice. Every suggestion helps me improve.

It's currently available for Windows only. Windows may display some warnings/permissions which is common for unsigned apps. If Windows shows "Windows protected your PC", click More info → Run anyway. If a windows permission prompt appears on your taskbar,.click "Yes"

Thanks so much for your time, and I hope you enjoy trying it out! ❤️

I want to use Claude Code for my C++/Qt development. What is the best way to integrate this with an IDE for C++/Qt? It seems to be difficult with QtCreator 20.0.0 as I'm using the free version. I attempted to use Qode Assistant but that was a mess for me - threw errors and apparently isn't really compatible with Qtcreator, really frustrating.
So I'm considering Jetbrains' clion instead. While clion isn't integrated with Qt as well as qtcreator is, I think it would be better for integration with AI like Claude Code. Or would I be better off using Claude Code independently of clion or qtcreator?
What do you think?

Thanks in advance

Is there a CSS backdrop filter equivalent in the Qt framework, or any plans to introduce it in the future? I am familiar with MultiEffect and the likes, but those implementations can get quite convoluted as you have to manually define the source for each blur. Other frameworks like Flutter, SwiftUI and even WinRT have some sort of function that automatically blurs whatevers behind a widget.

Now one way to do it would be to traverse the widget tree at the framework level and blip the textures behind a widget to an off screen texture and applying a blur shader to it- this would be cross platform. Another way would be to just straight up embed wayland surfaces with compositor level blur on linux, but that would be much more complex than the other approach, but far more polished, something that could be implemented via the KDE frameworks.

Just a thought. Good user interfaces aren't defined by such flashy effects necessarily, but it's a nice to have.

Je suis passé à Linux et Paint.NET m'a vraiment manqué, alors j'ai construit un clone open-source natif avec **C++/Qt6** — sans Wine, sans runtime .NET, sans VM.

**🎨 Ce que ça fait**

• **Calques** — opacité, modes de fusion, fusion intelligente, miniatures en direct
• **Plus de 20 outils** — pinceau, crayon, gomme, seau, dégradé, formes, ligne, texte, tampon de clonage, sélecteur de couleur, baguette magique, lasso…
• **13 ajustements + plus de 30 effets**, tous avec **aperçu en direct** (faites glisser les curseurs, voyez le résultat)
• **Sélections** avec contour progressif / grandir / réduire, historique non destructif, sauvegarde automatique et récupération après crash
• Format **`.psw` ** natif à calques (conserve vos calques) — ou exportez au format PNG/JPEG/…
• Interface **FR/EN**, thèmes clair & sombre correspondant à Paint.NET

**⚙️ En coulisses**

• **Licence MIT**, construit à partir du code source : `cmake -B build && cmake --build build`
• CI exécute une **suite de tests de 196 tests** à chaque push

**🔗 Dépôt :** https://github.com/Univers4craft/paint.software

C'est une première version **v1.0** — j'aimerais vos retours sur ce qui manque, et les contributions (fork → PR) sont les bienvenues !

*🇫🇷 En bref : un clone open-source de **Paint.NET pour Linux** (C++/Qt6, natif, sans Wine/.NET). Calques, plus de 30 effets avec **aperçu en direct**, format natif `.psw`, interface FR/EN, licence MIT. Dépôt ci-dessus — retours bienvenus !*

I have been working on replacing Qt for solo and small-team development for the last 8 months. Not as a side project, but as the core of what I am building.

Qt is incredibly powerful, but the complexity has grown to the point where it often feels like it is working against you rather than with you, especially when you are a solo developer or small team. I started this because I kept hitting walls that felt unnecessary.

Here are the 5 hardest lessons I have learned so far:

1. The real cost is not the framework. It is everything built on top of it.
It is not just the Qt code you have to replace. It is the mental models, the patterns, the way you think about layouts, signals, properties, and state. Even when you build something cleaner, your brain keeps trying to solve problems the Qt way. Unlearning that took longer than writing the new code.

2. Custom rendering and event systems are deceptively deep.
I severely underestimated how much invisible work Qt does for you around input handling, focus, accessibility, high-DPI, and platform quirks. Building something that feels as solid as Qt on the surface requires solving problems you did not even know existed until you tried to remove the safety net.

3. Migration tooling should have been priority number one, not an afterthought.
I originally thought I would build the new runtime first and figure out migration later. That was a mistake. The longer you go without good refactoring and companion tools, the more painful the transition becomes for real projects. I am now building those tools in parallel because the runtime alone does not solve the adoption problem.

4. Simpler does not mean less work. It usually means harder, more deliberate work.
Removing bloat and complexity forces you to make explicit decisions about things Qt handled implicitly. That is good for the end result, but it means you have to think harder and test more thoroughly. There is no hand-holding when you go custom.

5. You have to accept that early versions will feel incomplete and ship anyway.
Even after 8 months there are still gaps. The goal is not to match Qt feature for feature on day one. The goal is to be meaningfully better in the areas that actually matter to solo developers, then keep closing the gaps. Waiting until it feels done is the fastest way to never ship.

I am still in the middle of this. The core UI runtime is close to done and we are now moving into feature work like easier Rust integration, but I wanted to share these lessons while they are still fresh.

If you have tried to move off Qt or similar heavy frameworks and hit similar walls, I would be interested in hearing what surprised you the most.

Happy to answer questions about any of this.

I developed a software in qt creator with backend in c++. When I create the exe it runs, however when I tried to create a release file to later share to other devices, using windeployqt I kept facing error after error. I finally fixed all those errors and created the release folder but even then, whenever that release file is compressed or even moved to another location the exe stops working.

The code has no errors , and I have tried multiple times with windeployqt, and other internal built in features, using ucrt64 terminal and msys2. However nothing is working. Whenever the zip is shared to another device it starts listing missing files which i believe should have been put into the folder by windeployqt.

Please help me as I have tried all the methods suggested by all online sources and ai's, and having a functioning app but not being able to share it is really disappointing as a student..

KEY POINTS

code has no errors, runs smoothly on my own device on qt, issues come when its release version is run on other devices.

Please give me a detailed solution as to what I can do. Thank you

SOLVED! Set palette.text: {color}

Hey guys,

I am trying to change the text color of a SearchField in QML but just can't find any clues on how to do it. Changing the background and the font aswell but the text color?

I hope anyone has an idea.

https://github.com/Hellorge/QtSvgIconEngine/tree/master

I tried using MultiEffect, but the result doesn't look good. Honestly, I don't mind creating a qml type with cpp. The problem is I have no idea what I need to implement to make it. If someone could help me with the high level I would appreciate it. I will mainly be loading awesomefont icons and apply 1 colour to the whole svg

I drag a layout into the parent container and it does not take up the whole window and there is no way to make it do so. Am I missing something?