Skip to content
BSWEN
Blog

PySide vs PyQt for Python Desktop Apps: Which Should You Choose in 2026?

Cowrie
Cowrie
Dev @ Bswen

I was building a Python desktop application for a client when I hit a licensing wall. I’d been happily coding with PyQt for months, only to discover—weeks before deployment—that I owed thousands in licensing fees. The client wasn’t thrilled.

Here’s what I learned the hard way about PySide vs PyQt, and why choosing the right one upfront can save you from expensive surprises.

The Licensing Trap

Both PySide and PyQt are Python bindings for Qt—the most feature-complete GUI framework available. They have nearly identical APIs. Your code will look almost the same regardless of which you choose.

The difference? Licensing.

License Comparison
┌─────────────┬──────────────────┬─────────────────────────┐
│   Library   │     License      │   Commercial Use Cost   │
├─────────────┼──────────────────┼─────────────────────────┤
│   PySide    │     LGPL v2.1    │   $0 (free)             │
│   PyQt      │     GPL v3       │   ~$550/developer/year   │
└─────────────┴──────────────────┴─────────────────────────┘

This single difference can cost your project thousands—or force you to open-source your entire codebase.

Understanding GPL vs LGPL

GPL (PyQt’s License)

The GPL is a “copyleft” license with teeth:

GPL Requirements
Your Application
       │
       ▼
┌──────────────────┐
│  Uses PyQt (GPL) │
└──────────────────┘
       │
       ▼
┌──────────────────────────────────────┐
│  Your ENTIRE app must be GPL:        │
│  • Release ALL source code           │
│  • Allow modifications               │
│  • Allow redistribution              │
│  • No proprietary restrictions       │
└──────────────────────────────────────┘

If you use PyQt and distribute your application, you must either:

  • Release your complete source code under GPL (anyone can use/modify it)
  • Buy a commercial license (~$550 per developer, per year)

There’s no middle ground. This catches many developers off guard.

LGPL (PySide’s License)

LGPL is far more permissive for commercial use:

LGPL Freedom
Your Application (Proprietary)
       │
       ▼
┌──────────────────┐
│  Uses PySide     │
│  (LGPL)          │
└──────────────────┘
       │
       ▼
┌──────────────────────────────────────┐
│  You can:                            │
│  • Keep your source code private     │
│  • Sell your application             │
│  • Add any license you want          │
│  • No fees required                  │
└──────────────────────────────────────┘

The key: you’re dynamically linking to PySide, not statically linking or modifying it. As long as users can replace the PySide library (which they can with standard Python installations), LGPL imposes no obligations on your proprietary code.

Real-World Cost Analysis

I ran the numbers for our team:

5-Developer Team, 3-Year Project
┌──────────────┬────────────────┬────────────────┐
│   Option     │   Year 1       │   3-Year Total │
├──────────────┼────────────────┼────────────────┤
│   PySide     │   $0           │   $0           │
│   PyQt       │   $2,750       │   $8,250       │
└──────────────┴────────────────┴────────────────┘


PyQt cost = 5 developers × $550/year

For a startup or small company, $8,250 is significant. That could be a senior developer’s salary for a month.

Feature Comparison: They’re Nearly Identical

After using both extensively, here’s what I found:

API Differences

pyside_example.py
# PySide6 import
from PySide6.QtWidgets import QApplication, QMainWindow, QLabel


app = QApplication([])
window = QMainWindow()
window.setCentralWidget(QLabel("Hello PySide!"))
window.show()
app.exec()
pyqt_example.py
# PyQt6 import (nearly identical)
from PyQt6.QtWidgets import QApplication, QMainWindow, QLabel


app = QApplication([])
window = QMainWindow()
window.setCentralWidget(QLabel("Hello PyQt!"))
window.show()
app.exec()

The only difference? Import statements. Most code ports between them with a simple find-and-replace.

Performance

Identical. Both libraries are Python bindings over the same Qt C++ backend. The Python overhead is the same. I benchmarked both and found no measurable difference.

Documentation and Community

Ecosystem Comparison
PyQt:
  ✗ More tutorials and StackOverflow answers (older ecosystem)
  ✗ More third-party examples
  ✓ GPL licensing complications for commercial use


PySide:
  ✓ Official Qt Company support
  ✓ Rapidly improving documentation
  ✓ LGPL licensing for commercial projects
  ✗ Slightly fewer legacy tutorials

Feature Lag

PySide occasionally lags behind C++ Qt by a few weeks to months. In practice, I’ve never encountered a situation where this mattered for typical desktop applications. Unless you’re bleeding-edge Qt features, you won’t notice.

The Decision Matrix

When to Choose What
┌─────────────────────────────────┬──────────────────────┐
│         Your Situation          │      Recommendation   │
├─────────────────────────────────┼──────────────────────┤
│ Commercial/closed-source app   │      PySide6          │
│ Startup with limited budget     │      PySide6          │
│ Enterprise with budget         │      Either works     │
│ Open-source/GPL project        │      Either works     │
│ Need specific PyQt tutorial    │      PyQt (if GPL OK) │
│ Long-term commercial product   │      PySide6          │
└─────────────────────────────────┴──────────────────────┘

Common Mistakes I’ve Seen

  1. Assuming PyQt is free for commercial use - It’s not. The GPL catches many by surprise.

  2. Not understanding GPL obligations - Using GPL code in your app means your app becomes GPL. No exceptions.

  3. Mixing up PyQt5 vs PyQt6 licensing - Same restrictions apply to both versions.

  4. Choosing based on tutorial quantity - More tutorials doesn’t matter if the licensing breaks your business model.

  5. Ignoring license costs until deployment - Discovering you owe $2,750/year per developer right before launch is painful.

Migration: Simple if Needed

If you started with PyQt and need to switch:

Migration Steps
# 1. Install PySide6
pip install PySide6


# 2. Replace imports (automated)
find . -name "*.py" -exec sed -i 's/PyQt6/PySide6/g' {} \;
find . -name "*.py" -exec sed -i 's/PyQt5/PySide2/g' {} \;


# 3. Handle minor API differences
# Most apps require < 10 lines of manual changes

My Recommendation

For 2026 and beyond: Start with PySide6.

The licensing clarity alone makes it the right choice for most commercial projects. The Qt Company’s official support and rapidly improving documentation make it a safe long-term bet.

Only choose PyQt if:

  • You’re building GPL open-source software
  • Your company already has PyQt commercial licenses
  • You need a specific third-party library that only works with PyQt

The hours you might save with PyQt’s larger tutorial base will cost you thousands in licensing fees later.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: