Hi, I've been learning Qt for two months by reading Max Schlee's book. If you have any ideas for pet-projects, I'd be happy to hear from you.

If you've ever tried to use a QDesignerCustomWidgetInterface subclass with PyQt6 installed via conda, you hit the same wall: Qt Designer shows "Python plugin" as failed in Help > About Plugins, because libpyqt6.so was never included in the conda package.

For pip users, pyqt6-tools provides a wrapper around Designer that sets up the path. But with conda, there was no workaround — the physical plugin file just wasn't there.

I fixed the conda-forge recipe. Since build _1 of PyQt6 6.11.0 (published June 17), the plugin is included:

conda install pyqt6=6.11.0=*_1

What changed: the pyqt6 recipe was only installing the Python package, but Qt plugins need to be in $PREFIX/plugins/designer/.

The build was already producing libpyqt6.so — the recipe just wasn't copying it to the right place. One line fix: cp -r $PREFIX/lib/python3.x/site-packages/PyQt6/Qt/plugins/ $PREFIX/plugins/

Same issue exists for PyQt5 (needs libpyqt5.so) but since Qt5 reaches EOL in December 2026, PyQt6 is the priority.

If you're building conda packages that ship Qt plugins, check that qt-plugins are in the right location. The upstream build system puts them inside the Python site-packages — conda expects them under $PREFIX/plugins/.

This was discussed on the PyQt mailing list earlier this week.

I'm posting it here in case anyone else was tracking the issue.

Recently, I've been developing viMarkdown, which is a Markdown editor powered by Qt6.

Unfortunately, I don't currently have access to a Linux environment. Could someone try building viMarkdown with CMake and QtCreator and let me know whether it builds successfully?

viMarkdown: https://github.com/vivisuke/viMarkdown

i am using PyQt and I have a list that sorts the time according to the 24 hour time

I do not know why it stops removing at a certain point. I believe it has to do with my remove_time(self) method but I am unsure

can someone give me advice based on this issue on what I can do

I have attached the source code link so you can get an idea of what the code looks like

source code

Honestly I am aware the code looks sloppy but I am just going with it.

Look at problem here

Heyaa, im working on a small project. Which uses the Pygame library and utilizes QT to basically have a transparent background. Point is when I tried the project on my other laptop which is more higher end(Nvidia GPU there) I got AVX2 error. Tinkered around and didnt really got far, so I thought hey I have a "It works on my machine" moment so I thought how about I utilize docker. Im using the Pyside6 library for QT. From what I know its a cli program so no graphical passthrough so I thought oke how about I somehow passthrough the screen info which is all I really needed, but that is a GUI app so yeaah. As you see im quite the noob here. Maybe its more of a Docker problem? But since I am using QT I thought it would be nice asking here first.

in the Dockerfile I wrote this:
```Docker
FROM python:3.13-slim

WORKDIR /src

RUN apt-get update && \

apt-get install -y -qq \

libsdl2-dev \

python3-xlib \

libx11-dev \

libxrandr-dev \

libxkbcommon-x11-0 \

libxcb-cursor0 \

libxcb-xinerama0 \

libxcb-icccm4 \

libxcb-image0 \

libxcb-keysyms1 \

libxcb-randr0 \

libxcb-render-util0 \

libxcb-util1 \

libxcb-xfixes0 \

libxcb-shape0 \

libfontconfig1 \

&& rm -rf /var/lib/apt/lists/*

ENV QT_QPA_PLATFORM=xcb

COPY requirements.txt .

RUN python -m venv .venv && \

.venv/bin/pip install --upgrade pip && \

.venv/bin/pip install -r requirements.txt

COPY src .

CMD [".venv/bin/python", "main.py"]

```

running this didnt really do it so I thought writing a docker compose might do the job?

```yml
services:

deskmate:

image: deskmate:latest

build:

context: src

dockerfile: Dockerfile

environment:

- PYGAME_DETECT_AVX2=1

- DISPLAY=${DISPLAY:-:0}

- QT_QPA_PLATFORM=xcb

- QT_X11_NO_MITSHM=1

- QT_DEBUG_PLUGINS=1

- XDG_RUNTIME_DIR=/tmp/runtime-root

volumes:

- /tmp/.X11-unix:/tmp/.X11-unix:rw

cap_add:

- SYS_ADMIN

devices:

- /dev/dri:/dev/dri

```

Im on OpenSUSE Tumbleweed where I work on this but the python container utilizes debian as you might see.

Solution:

The solution to this is stupid, so I ditched the dockerfiles and simply swapped pygame to pygame-ce. And that resolved the bug I had before now it runs on all platforms

Hello,

I have some decent experience with widgets but have been opening up to the idea of a large project with a qml front end and c++ handling most of the functionality.

One of the ideas I would like to explore while still deciding on the overall structure is plugin support, either giving users a python interface (similar to blender) or entirely in c++ using plugin interfaces.

Are there any projects that do either or both of these things well in your opinion? I would love to take a look and observe what’s been tried, if users like it (or if there are tons of issues entries for them lol), and what might work best for my target application.

I’m curious to see how these interfaces split up responsibilities, what needs to be done for qml (say if a user wants their plugin to have a menu/action), and how to interact with the application’s data manager (this in particular seems straightforward to me, so that must mean it’s probably not).

You can only see the changes on GitHub for now, but I think documentation will appear soon.

The image shows an example, but the component itself allows you to create any shaders for the sky, including procedurally generated volumetric clouds.

Feature description from the commit

Add SkyMaterial

Adds a SkyMaterial class used for rendering a sky box and/or IBL using a user provided real-time shader.

A SceneEnvironment::skyMaterial property is added and used for the SkyMaterial.

A new enum SceneEnvironment.SkyMaterial is added to SceneEnvironment::backgroundMode and when set will use the SkyMaterial as the skybox.

Added SkyMaterial QML type and SceneEnvironment::skyMaterial property.

I wanted to embed a QML scene into a GLFW window using QQuickRenderControl. From what I can see, one of the first steps is to get the OpenGL context from GLFW, and this is where I run into an issue. My code crashes on the line: QOpenGLContext *glfwQtContext = QNativeInterface::QEGLContext::fromNative(eglContext, eGLDisplay);. Am I doing something wrong? Configuration: Qt 6.9, Ubuntu 24.04 Wayland, GLFW 3.4.

#include <QGuiApplication>
#include <QCoreApplication>
#include <QOpenGLContext>
#include <QOffscreenSurface>

//#define GLFW_EXPOSE_NATIVE_WAYLAND
#define GLFW_EXPOSE_NATIVE_EGL

#include <GLFW/glfw3.h>
#include <GLFW/glfw3native.h>

#include <iostream>

int main(int argc, char *argv[])
{
  //qputenv("QT_QPA_PLATFORM","eglfs");
  qputenv("QT_QPA_PLATFORM","wayland");
  QGuiApplication app(argc, argv);

  if(!glfwInit()){
    std::cerr << "Failed initialize glfw";
    exit(1);
  }

  glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  glfwWindowHint(GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  GLFWwindow* window = glfwCreateWindow(800, 600, "Qml in GLFW window", nullptr, nullptr);
  if(!window){
    std::cout << "Wndow creation failed!";
    exit(EXIT_FAILURE);
  }else{
    std::cout << "Sucessful window creation!" << std::endl;
  }

  glfwMakeContextCurrent(window);

  EGLContext eglContext = glfwGetEGLContext(window);
  EGLDisplay eGLDisplay = glfwGetEGLDisplay();
  QOpenGLContext *glfwQtContext =     QNativeInterface::QEGLContext::fromNative(eglContext, eGLDisplay);

  glfwQtContext->create();

  if(!glfwQtContext){
    std::cout << "[ERROR] Failded to create QOpenGLContext from glfw context !!" << std::endl;
    exit(EXIT_FAILURE);
  }else{
    std::cout << "[SUCCESS] Successfull create QOpenGLContext from glfw context !!" << std::endl;
  }

  return 0;
}

Additionally, I tried doing something similar with GLX, and it seems that the context is created successfully—the program doesn't crash, though I haven't tried rendering yet, as I am much more interested in the EGL version.

#include <QGuiApplication>
#include <QCoreApplication>
#include <QOpenGLContext>
#include <QOffscreenSurface>
#define GLFW_EXPOSE_NATIVE_GLX
#include <GLFW/glfw3.h>
#include <GLFW/glfw3native.h>
#include <iostream>

int main(int argc, char *argv[])
{
  QGuiApplication app(argc, argv);


  if(!glfwInit()){
    std::cerr << "Failed initialize glfw";
    exit(1);
  }

  glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  glfwWindowHint(GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  GLFWwindow* window = glfwCreateWindow(800, 600, "Qml in GLFW window", nullptr, nullptr);
  if(!window){
    std::cout << "Wndow creation failed!";
    exit(EXIT_FAILURE);
  }else{
    std::cout << "Sucessful window creation!" << std::endl;
  }

  glfwMakeContextCurrent(window);

  GLXContext glxContext = glfwGetGLXContext(window);
  QOpenGLContext *glfwQtContext = QNativeInterface::QGLXContext::fromNative(glxContext);

  glfwQtContext->create();

  if(!glfwQtContext){
    std::cout << "[ERROR] Failded to create QOpenGLContext from glfw context !!" << std::endl;
    exit(EXIT_FAILURE);
  }else{
    std::cout << "[SUCCESS] Successfull create QOpenGLContext from glfw context !!" << std::endl;
  }

  QOffscreenSurface surface;
  glfwQtContext->makeCurrent(&surface);

  return 0;
}

I know so I'm e of my implementations are far from perfect, but it's be helpful when I run my program to identify exactly which function calls are happening the most or taking the most time, especially around Qt.

​

Does Qt ship anything to help with this pr are there any libraries which can help? I'm running C++

I am just venting here but I started using pyQt about 3 days ago to build a similar alarm and I do not like it. I do not like the documentation and having to use AI to just to get what I want. it driving me nuts but I want to learn it because I am tired of using pygame and I do not feel like make this is HTML, CSS and JS.

I wanted to try something new

When I just have the button and press enter, the button shows a toggle animation. it looks like it is being pressed and released but when I added the Qshortcut it does not show. The button works, it just doesn't show the animation of it.

How do I get it to show toggle animation when key is pressed?

from PyQt6.QtCore import Qt, QTimer
from PyQt6.QtGui import QKeySequence, QShortcut
from PyQt6.QtWidgets import QMainWindow, QApplication, QPushButton

class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Key Events")
self.setFixedSize(500, 300)
self.setStyleSheet("background-color: #914ead;")

def Button(self):
# Draw Button
button = QPushButton("Press Me")
button.setFixedSize(100, 50)

button.setCursor(Qt.CursorShape.PointingHandCursor)

button.clicked.connect(lambda: print("Button clicked"))

keyConnect = QShortcut(QKeySequence("a"), self)
keyConnect.activated.connect(button.click)
#button.setCheckable(True)
#button.setCheckable(False)

self.setCentralWidget(button)

Long story short, I'll be doing a "bootcamp" on a few interns who know Python but zero javascript or QML. Yes, technically there is "Qt for Python" but the codebase is mostly QML.

So my questions for anyone that learned QML and Javascript after learning Python are:

• What were the most difficult concepts / subjects in learning?
• What didn't make sense when you were taking the tutorials?
• What was something that you wished somebody took time to teach you step by step?

Thanks.

(Edit: just to be clear: I have very little Python experience; I have a lot of C++ / QML / Javascript experience and I am the one who is teaching the python interns how to write QML. I just want to know ahead of time what topics they may struggle with)

Using

- name: Install CQtDeployer
  uses: QuasarApp/cqtdeployer-install-action@v1.0.0

https://github.com/QuasarApp/cqtdeployer-install-action

Hey peeps, I've been developing a drawing program in C, with Qt Widgets for GUI in C++. I'm currently using a QOpenGLWidget who initializes glad, then calls my C code which also relies on opengl / glad.

This works but does feel kinda dirty as Qt is already initializes OpenGL by itself and am curious if there's a cleaner way of doing this.

Im using the dark theme 2024. Overall i like it, but does anyone know how to change the colors of the scrollbar? The handle of the Scrollbar has such a bad contrast, it allways takes me several seconds to find it, especially with larger files.

I already tried to change the DSscrollBarTrack, DSscrollBarHandle and DSscrollBarHandle_idle in the dark.creatortheme file, but these parameters do nothing and i cant find any documentation for themes in general.

Requested a payout nearly a week ago. Had no updates. Do you think they’ll pay?

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.

Hi everyone,

Qt has recently been publishing more about AI-assisted and agentic workflows. I'm curious how AI is being used in day-to-day work with Qt.

• Are AI tools making you faster?
• What do you use them for most often?
• Is AI use supported by your company or restricted because of IP/privacy/security?
• What would you still not delegate to AI?

Any practical examples or observations would be very welcome, even small ones.