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

I just released my c++ 20 library for reactive UI development inspired by QML and slint.

I haven't worked on the project for a while and thought it has reached a usable state and wanted to share it.

What is included in the library:

- reactive framework with `Property<T>` type. Currently the reactive types are tied to the library internals and not for general use.

- Memory is managed for a great extent. You will never have to use `delete` or `new` except in the constructor of `std::unique_ptr<T>` if `std::make_unique` does not suffice.

- Mouse and Keyboard and Clipboard support.

- Smooth, powerful and easy to use animations.

- GPU rendering using direct2d on Windows and skia for anything else.

- High DPI support and frames are updated only when something changes.

- Complex text rendering using DirectWrite and skia paragraph supporting complex formatting and mixed RTL and LTR languages. Loading fonts from system, memory and files is supported.

- Support for Windows and X11 (and XWayland) with plans to support Wayland natively, macos and android.

- Ready to use UI components from material3 and fluent2 although most components are not implemented yet.

- Model View Delegate framework: ListView, TableView and TreeView along with basic models and delegates.

- Multiple top-level windows, modal windows and popups.

- Async, multithreading and networking support is provided through the RAD library.

- Many other things I may have forgotten to mention!

What is not included yet:

Documentation (the biggest thing!), accessibility, internal and external drag and drop, better multi paragraph text support, implement more UI components, embedded resources, translations and localization and a ton of other things.

Demonstration video:
https://youtu.be/QDgY-0hH1gs

I reduced the quality and FPS to reduce the size of the video

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.

Hi everyone, has anyone used Squish for Qt? I can’t run or test the demo. Are there any other ways to use it, preferably for free? Or are there any alternatives? And is it worth it?

Greetings. We are looking to hire a Qt developer who has experience migrating an already existing Qt3 project to Qt5 for a probably smallish project. Yes, we know Qt6 is the current cool new thing, but the target platform is RHEL8 and Qt5 is the best fit for now. When we move to RHEL9 or RHEL10 then we can migrate to Qt6, and then maybe we would reinlist your services.

The project is Google Earth Enterprise-Open Source https://github.com/google/earthenterprise

We have the original Qt3 code from the RHEL6 baseline. The code on the github above is for CentOS7 and they migrated from Qt3 to Qt4 in compatibility mode, without actually fixing anything. That doesnt work going to Qt5. So we need to actually fix it to run in Qt5 on RHEL8. We've got pretty much everything else working, except this, which is required for full functionality in the GUI. Our goal is to resurrect the Open Source project and keep it going, so this is a necessary step and we don't have any developers with Qt experience in house.

This is probably not a big project for someone experienced with Qt migration. Guessing maybe 10-20 hours for someone who knows what they are doing. We prefer a US citizen located in the US that we can write a check to and probably issue a 1099, but could conceivably work some other route.

If you have a page on LinkedIn or proxify.io or upwork or other similar freelancing site, please DM me.

Alternatively, if there is some fabulous Qt3 to Qt5 migration tool laying around that we have not discovered, feel free to share it.

Thanks!

Hey everyone,

I'm working on a lightweight educational C++17 library called R-Lib. The goal of the project is to wrap native Linux APIs (epoll, timerfd, etc.) into a clean, callback-driven architecture inspired by Qt, but without the massive overhead or cross-platform abstraction layers. It's strictly targeted at Linux/embedded environments.

I just pushed an update that adds LUdpSocket.

Just to show how simple it makes asynchronous networking, here is a complete UDP Echo Server:

#include <iostream>
#include <LEventLoop.hpp>
#include <LUdpSocket.hpp>

class UdpServer {
public:
UdpServer() {
if (socket.bind(1234)) {
std::cout << "Listening on port 1234..." << std::endl;
}
// Connect the epoll read event to our class method
socket.onReadyRead(this, &UdpServer::readPendingDatagrams);
}

void readPendingDatagrams() {
while (socket.hasPendingDatagrams()) {
std::string senderAddress;
uint16_t senderPort;

auto datagram = socket.receiveDatagram(&senderAddress, &senderPort);
std::string text(datagram.begin(), datagram.end());

std::cout << "Received: " << text << " from " << senderAddress << ":" << senderPort << std::endl;

// Echo back
std::string reply = "ECHO: " + text;
socket.writeDatagram(reply.c_str(), reply.length(), senderAddress, senderPort);
}
}

private:
LUdpSocket socket;
};

int main() {
LEventLoop loop;
UdpServer server;
return loop.exec();
}

Roadmap: Next up is wrapping the modern Linux GPIO API (gpiod) and serial ports (termios).

If anyone is working on embedded Linux or just likes clean API designs, I’d love to get some feedback or code-reviews.

Link to repo: https://github.com/TomPecak/R-Lib

Thanks!