This repository provides 212 README.md for PySide6 official examples (v6.9.1), into a GitHub-native format, ensuring developers and AI models can efficiently access a well-known platform aligned with 2025 requirements.
Navigating PySide6’s official documentation can be challenging, especially for AI models or developers seeking structured access. This 2025 repository bridges that gap by providing GitHub-native documentation, making example navigation, indexing, and integration convenient for current LLMs common tools like MCP Servers.
- Up-to-date implementation (v6.9.1) – PySide6modern.md ensures modern usage to counteract LLM biases toward deprecated versions.
- 212 New README.md files – Each example project now includes a dedicated README.md file, accompanied by a screenshot (if available) for visual clarity.
- Comprehensive project index – A centralized list of all example descriptions, including screenshots (where applicable), for quick reference and discovery.
- Documentation Project files – tools contains files required for generating this documentation, which can also be adapted for other libraries.
- Cool GUI Example - best_gui.py an example of mixed features in one file, usefull to share with AI for basic starting.
Simple 3D Example This example demonstrates how to create a basic 3D scene using PySide6 and the Qt3D module. It showcases Setting up, Creating 3D geometric primitives, Applying transformations, Using basic shading, Configuring a 3D camera, Enabling user interaction for camera manipulation, Implementing a simple property-based animation.
Asynchronous Sieve of Eratosthenes Example This example demonstrates the Sieve of Eratosthenes algorithm for finding prime numbers up to a specified limit. The core computation is performed asynchronously, showcasing how to integrate long-running tasks with a PySide6 GUI without freezing the user interface. Two distinct Python asynchronous frameworks are used in separate files. Both versions visualize the algorithm's progress by dynamically updating a grid of numbers, changing their color as they are identified as non-prime. This highlights how PySide6 can work effectively with modern Python asynchronous programming.
Minimal Asynchronous Examples This example provides a set of minimal, "barebones" illustrations of how to integrate asynchronous operations with a simple PySide6 application. It demonstrates how an asynchronous task, triggered by user interaction (a button click), can perform a delayed update to the User Interface (changing text in a label) without blocking the GUI.
ActiveX Viewer (QAxContainer) Example This example demonstrates the use of the QAxContainer.QAxWidget class from PySide6 to embed and display an ActiveX control within a Qt application. It provides a generic viewer that allows the user to select any registered ActiveX control on their Windows system through a standard dialog and then hosts that control in the main window.
Bluetooth Scanner Example This example demonstrates how to use PySide6's QtBluetooth module to scan for nearby Bluetooth devices, display their information, manage local Bluetooth adapter settings, initiate pairing, and discover services offered by classic Bluetooth devices. It consists of two main dialogs: one for device discovery and local adapter management, and another for discovering services on a selected remote device.
Bluetooth Heart Rate Game Example This example demonstrates how to use PySide6's QtBluetooth module to discover, connect to, and interact with a Bluetooth Low Energy (BLE) heart rate monitor. The application scans for nearby BLE heart rate sensors, allows the user to connect to one, and then displays the live heart rate data. It also calculates simple statistics like minimum, maximum, average heart rate, and estimated calories burned. The UI is built using QML and includes a basic "game" page where the heart rate might visually influence elements, along with pages for device connection and statistics display. A simulator mode is also available for development without a physical device.
Bluetooth Heart Rate Server Example This example demonstrates how to use PySide6's QtBluetooth module to create a Bluetooth Low Energy (BLE) peripheral that simulates a standard GATT Heart Rate sensor. The application sets up a Heart Rate service, advertises it, and allows BLE clients (like mobile phones or other Bluetooth-enabled devices) to connect, and subscribe to notifications for heart rate measurements. The heart rate value is dynamically updated by the server, simulating a live heart rate.
Bluetooth Low Energy Scanner Example This example provides a utility to scan for Bluetooth Low Energy (BLE) devices, connect to a selected device, and perform a comprehensive exploration of its Generic Attribute Profile (GATT) hierarchy. It allows users to discover services, and for each service, discover its characteristics, view their properties, and read their current values and descriptors. The UI is built using QML, with a Python backend managing Bluetooth communications.
Area Chart Example (QtCharts) This example demonstrates how to create and customize a simple area chart using the QtCharts module in PySide6. It illustrates the process of defining the upper and lower boundaries of an area using two QLineSeries objects and then combining them into a QAreaSeries. The example also shows how to customize the appearance of the area chart, including setting a pen for its border and applying a linear gradient for the fill. Default axes are created and their ranges are subsequently adjusted.
Real-time Audio Level Chart Example This example demonstrates how to capture audio input from a microphone using the QtMultimedia module and visualize its raw waveform in real-time on a line chart using the QtCharts module in PySide6. It shows how to set up an audio input stream, process the incoming raw audio data (normalizing it), and dynamically update a line series to reflect the live audio signal.
Bar Chart Example (QtCharts) This example demonstrates how to create a grouped bar chart using the QtCharts module in PySide6. It shows how to define multiple QBarSet objects (each representing a different data series, e.g., sales figures for different individuals), populate them with data, and group them under common categories (e.g., months). The example covers setting up category and value axes, enabling chart animations, and configuring the legend.
Chart Callout Example (QtCharts) This example demonstrates how to implement custom interactive callouts (tooltips) on a Qt Chart. The callouts appear when hovering over data points on line or spline series, displaying the coordinates of the point. Furthermore, clicking on a data point makes the currently displayed callout persistent, allowing multiple callouts to be visible simultaneously. The example also shows how to display live mouse coordinates relative to the chart axes.
Chart themes This example demonstrates the use of built-in themes in QtCharts to alter the appearance of various chart types. It showcases how different chart elements (series, axes, legend, background) are affected by themes like "Light", "Dark", "Blue Cerulean", and others. The application provides a user interface that allows for dynamic switching between these themes. Additionally, it offers controls to toggle chart animations, legend visibility and alignment, and anti-aliasing, applying these settings across multiple chart instances simultaneously.
A variety of chart types are displayed (Area, Pie, Line, Bar, Spline, Scatter) to give a comprehensive view of the theme's impact.
Donut Breakdown Chart Example (QtCharts) This example demonstrates how to create a complex, segmented donut chart using QtCharts in PySide6. It showcases a technique where multiple distinct QPieSeries (each representing a "breakdown" of a larger category) are visually arranged as segments of an outer conceptual donut. The size and angular position of each breakdown series are controlled by a primary QPieSeries, effectively creating a multi-level pie chart within a single chart view.
Dynamic Spline Chart Example (QtCharts) This example demonstrates how to create a spline chart that updates dynamically in real-time using PySide6's QtCharts module. New data points are generated periodically by a QTimer and appended to a QSplineSeries. The chart view automatically scrolls horizontally to follow the new data, creating an animated effect of a continuously drawn line. The example encapsulates the chart's logic within a custom QChart subclass.
Chart Legend Customization Example (QtCharts) This example provides a comprehensive demonstration of how to customize and interact with a chart legend using QtCharts in PySide6. It showcases a QBarChart and provides a user interface with various controls to dynamically Toggle the legend's attachment state, Modify the geometry, Change the alignment, Adjust the legend's font properties, Add or remove data sets.
Line and Bar Chart Example (QtCharts) This example demonstrates how to display both a QLineSeries and a QBarSeries on the same chart using QtCharts in PySide6. It showcases how both series can share a common category-based X-axis and a common value-based Y-axis, allowing for direct comparison of trends and magnitudes across different data representations.
Simple Line Chart Example (QtCharts) This example demonstrates the fundamental steps to create and display a simple line chart using the QtCharts module in PySide6. It focuses on creating a QLineSeries, populating it with data points, and displaying it using a QChart with automatically generated default axes.
Logarithmic Value Axis Example (QtCharts) This example demonstrates how to use a QLogValueAxis in QtCharts to display data that spans several orders of magnitude, or where a logarithmic scale is otherwise appropriate for visualizing relationships. It specifically shows how to configure a logarithmic scale for the Y-axis in a line chart, including setting a custom base for the logarithm.
System Memory Usage Pie Chart Example (QtCharts) This example demonstrates how to use QtCharts to visualize the current memory usage of running processes on the system. It fetches real process memory information by executing platform-specific system commands (tasklist on Windows, ps on Unix-like systems) via QProcess. The memory usage of the top consuming processes is then displayed as a QPieSeries (a pie chart).
Charting with Model Data (QtCharts) This example demonstrates how to use a custom Qt item model (QAbstractTableModel subclass) as a dynamic data source for multiple series in a Qt Chart. It showcases the use of QVXYModelMapper to link specific columns from the model to the X and Y coordinates of QLineSeries objects. The application displays the data simultaneously in a QChartView and a QTableView. Edits made to the data within the QTableView are automatically reflected in the chart, illustrating the power of Qt's model/view architecture extended to charts.
Nested Donuts Chart Example (QtCharts) This example demonstrates how to create a dynamic and interactive nested donut chart using QtCharts in PySide6. It showcases multiple QPieSeries objects arranged as concentric rings, each with its own set of slices.
Percent Bar Chart Example (QtCharts) This example demonstrates how to create a percent bar chart (also known as a 100% stacked bar chart) using the QPercentBarSeries class in PySide6's QtCharts module. In this type of chart, the height of each category bar is normalized to 100%, and the segments within each bar visually represent the relative percentage contribution of different data sets (e.g., sales figures for different individuals across several months).
Simple Pie Chart Example (QtCharts) This example demonstrates the fundamental steps to create and display a simple pie chart using the QPieSeries class in PySide6's QtCharts module. It covers adding slices with labels and values to a series, and basic customization of a single slice, such as exploding it, making its label visible, and changing its border and fill color.
Per-Point Configuration Example (QtCharts) This example demonstrates how to dynamically configure visual properties of individual data points within a QLineSeries using QtCharts in PySide6. Users can click on a specific point in the line series, and then use UI controls to change that selected point's color, size, label visibility, and custom label text. This showcases the QXYSeries.PointConfiguration feature for fine-grained control over point appearance.
Point Selection and Custom Markers Example (QtCharts) This example demonstrates how to customize the visual appearance of data points in a QSplineSeries using custom image markers.
QML Polar Chart Example (QtCharts) This example demonstrates how to create various polar charts using Qt Charts within a QML application, leveraging PySide6 as the Python backend to run the QML environment. It showcases different series types—including SplineSeries, ScatterSeries, AreaSeries (composed of LineSeries), and LineSeries—rendered on a polar coordinate system. The example also illustrates the use of different axis types like ValueAxis, DateTimeAxis, and CategoryAxis for both angular and radial dimensions. Data is primarily defined directly within the QML.
Temperature Records Chart Example (QtCharts) This example demonstrates how to use QtCharts in PySide6 to display temperature records using a QStackedBarSeries. It visualizes monthly minimum and maximum temperatures as stacked segments within each bar, providing a clear comparison of temperature ranges across a year. The X-axis represents months (categories), and the Y-axis represents temperature in Celsius.
Zoomable and Pannable Line Chart Example (QtCharts) This example demonstrates how to implement comprehensive zooming and panning functionalities for a line chart using QtCharts in PySide6.
Shared Memory IPC Example (QSharedMemory) This example demonstrates Inter-Process Communication (IPC) using QSharedMemory in PySide6. It consists of a single dialog-based application. The example primarily showcases the use of QSharedMemory for sharing binary data (a QImage) between processes, with QDataStream and QBuffer facilitating the serialization and deserialization of the image.
MIME Types Browser Example (QMimeDatabase) This example demonstrates how to use QMimeDatabase to access and display information about all MIME types known to the system.
Settings Editor Example (QSettings) This example provides a comprehensive demonstration of using QSettings in PySide6 to persistently store and retrieve application settings of various data types.
Multithreading with QThread (Mandelbrot Example) This example demonstrates how to use QThread to perform a computationally intensive task—rendering a Mandelbrot fractal—in a separate worker thread. This approach ensures that the main application User Interface (UI) remains responsive while the complex calculations are in progress.
3D Bar Chart Example (QtDataVisualization) This example demonstrates the fundamental steps to create and display a simple 3D bar chart using the Q3DBars class from the QtDataVisualization module in PySide6.
3D Graph Gallery (QtDataVisualization) This example provides a comprehensive gallery application showcasing various 3D graph types available in PySide6's QtDataVisualization module:
Minimal 3D Surface Plot Example (QtDataVisualization) This example provides a minimal demonstration of how to create a 3D surface plot using the Q3DSurface class from the QtDataVisualization module in PySide6.
QML 3D Surface Plot Gallery (QtDataVisualization) This example application showcases a gallery of various 3D surface plots created using the Surface3D QML type from QtDataVisualization, with PySide6 acting as the Python backend to run the QML environment.
3D Surface Plot Example (QtDataVisualization) This example demonstrates how to create and interact with 3D surface plots using the Q3DSurface class from PySide6's QtDataVisualization module.
3D Surface Plot with NumPy Data Model Example (QtDataVisualization) This example demonstrates how to create a 3D surface plot using QtDataVisualization in PySide6, where one of the data models for the surface is generated using NumPy arrays and then served to a QSurface3DSeries via a custom QAbstractTableModel and QItemModelSurfaceDataProxy.
3D Surface Plot with NumPy Data Example (QtDataVisualization) This example demonstrates how to create a 3D surface plot using PySide6's QtDataVisualization module, where the data for one of the surfaces (a mathematical "SqrtSin" function) is generated using NumPy arrays. It showcases a potentially optimized or specific way to feed this NumPy data directly to a QSurfaceDataProxy using a method like resetArrayNp(), which takes the NumPy array of Y-values along with parameters defining the X and Z grids.
D-Bus List Service Names Example This example demonstrates how to connect to the D-Bus session bus using PySide6's QtDBus module and retrieve a list of all currently registered service names. It showcases different approaches to call the ListNames method (or its equivalent) on the D-Bus daemon (org.freedesktop.DBus).
D-Bus Ping-Pong Example (Method Call/Reply) This example demonstrates basic Inter-Process Communication (IPC) using D-Bus between two console-based processes: "pong" (the service provider) and "ping" (the client). The "ping" process calls a D-Bus method named ping on an object exposed by the "pong" process. The "pong" process receives the call, processes it, prints a message, and returns a reply string to the "ping" process. After processing one call, the "pong" service gracefully exits.
Color Palette Client Demo (REST API and QML) This application demonstrates how to build a client that interacts with an external RESTful web service to fetch, parse, display, and manage data, specifically color palettes and user information (simulating an API like reqres.in or a simplified ColourLovers-like service).
Document Viewer Demo This application demonstrates how to build a multi-format document viewer in PySide6. It can display various file types (PDFs, images, JSON, plain text) by dynamically selecting and instantiating an appropriate viewer module for each document.
OpenStreetMap Buildings Viewer Demo (QML & QtQuick3D) This demo showcases a QML application that fetches and displays map tiles from OpenStreetMap (specifically the "HOT" style, which emphasizes buildings) and renders them in a 3D perspective view using QtQuick3D. It demonstrates:
Qt Designer Task Menu Extension Example This example demonstrates how to create a custom widget (TicTacToe), integrate it into Qt Designer using a plugin (QDesignerCustomWidgetInterface), and provide custom design-time actions for it via a Qt Designer Task Menu Extension (QDesignerTaskMenuExtension). The task menu allows developers to offer specific commands (like "Edit State...") for their custom widgets directly within the Qt Designer environment, enhancing the design-time experience.
Embedding Matplotlib 3D Plots in PySide6 This example demonstrates how to embed various Matplotlib 3D plots within a PySide6 application.
Embedding Matplotlib Gaussian Curve Plot in PySide6 This example demonstrates how to embed a Matplotlib 2D line plot within a PySide6 application. Specifically, it plots a 1D Gaussian probability density function (PDF) using data generated by scipy.stats.norm. The application provides interactive UI controls (QDoubleSpinBox widgets) to dynamically adjust the mean (μ) and standard deviation (σ) of the Gaussian distribution, with the Matplotlib plot updating in real-time to reflect these changes. The standard Matplotlib navigation toolbar is also integrated.
Visualizing NetworkX Graphs with PySide6 Graphics View This example demonstrates how to create and visualize graphs using the NetworkX library, with the rendering handled entirely by PySide6's Graphics View Framework (QGraphicsScene, QGraphicsView).
OpenCV Webcam Pattern Detection with PySide6 (using QThread) This example demonstrates how to integrate OpenCV with PySide6 to capture video from a webcam, perform real-time object detection using Haar Cascade classifiers, and display the processed video feed (with detected objects highlighted) in a Qt widget. The video capture and OpenCV processing are handled in a separate QThread to keep the main application UI responsive. Users can select different pre-trained Haar Cascade models (e.g., for detecting faces, eyes) via a ComboBox.
Displaying Pandas DataFrame in PySide6 QTableView This example demonstrates how to display data from a Pandas DataFrame within a PySide6 QTableView. It achieves this by creating a custom Qt model class (PandasModel) that inherits from QAbstractTableModel. This custom model acts as an adapter or wrapper around the Pandas DataFrame, allowing Qt's model/view architecture to interact with the DataFrame's contents and present them in a standard table view.
Scikit-image Color Deconvolution (H&E Stains) with Matplotlib in PySide6 This example demonstrates the integration of scikit-image for image processing and matplotlib for visualization within a PySide6 application. Specifically, it performs color deconvolution on an immunohistochemistry (IHC) sample image (typically stained with Hematoxylin and Eosin, and often DAB) to separate the different stain channels.
QML Audio Waveform Visualization using QtGraphs and Python Backend This example demonstrates how to create a real-time audio waveform visualization in a QML application. It utilizes a Python backend to capture and process audio data from a microphone via QtMultimedia, and then displays this data as a line graph in the QML frontend using the QtGraphs module.
"Hello Graphs" QML Example (QtGraphs) This example serves as an introduction to the QtGraphs QML module in PySide6. It demonstrates the basic setup required to display simple charts within a QML application.
QML 3D Bar Chart Example (QtGraphs) This example demonstrates how to create an interactive 3D bar chart using QML types from the QtGraphs module (the QML counterpart to Qt DataVisualization).
Minimal 3D Surface Plot Example (QtGraphsWidgets) This example provides a minimal demonstration of how to create a 3D surface plot in a PySide6 application using the Q3DSurfaceWidgetItem class from the PySide6.QtGraphsWidgets module. This component facilitates the integration of 3D surface visualizations, similar to those from the QtDataVisualization module, into applications.
QtGraphs Widget Gallery (3D Graphs in QtWidgets via QQuickWidget) This example provides a comprehensive gallery application showcasing various 3D graph types by embedding QML-based QtGraphs components into a PySide6 QtWidgets application.
Analog Clock Custom Window Example (QRasterWindow) This example demonstrates how to create a custom analog clock using PySide6. It showcases custom 2D graphics rendering with QPainter directly within a QRasterWindow (a QWindow subclass optimized for raster graphics). The clock displays the current time with hour, minute, and second hands that update every second, driven by a QTimer. The appearance of the clock elements (hands, background) is styled using colors from the application's current QPalette.
Qt Rendering Hardware Interface (RHI) Window Example This example demonstrates how to set up a custom QWindow to render graphics using Qt's Rendering Hardware Interface (RHI). RHI is Qt's internal graphics abstraction layer that sits on top of native graphics APIs like Vulkan, Metal, Direct3D, or OpenGL.
Simple HTTP Server Example (QHttpServer) This example demonstrates how to create a very basic HTTP server using PySide6's QHttpServer class from the QtHttpServer module. This high-level class simplifies the process of handling HTTP requests.
PySide6 Installer Test Example This example provides a simple PySide6 application (hello.py) along with a corresponding PyInstaller specification file (hello_app.spec). Its primary purpose is to serve as a basic test case for packaging PySide6 applications into standalone executables using PyInstaller.
QML Map Viewer Demo (QtLocation) This application demonstrates a comprehensive map viewer built primarily using QML and the QtLocation and QtPositioning modules. PySide6 is used as the Python runner to launch the QML application and pass initial plugin parameters.
Audio Output (QAudioSink) with Custom QIODevice Example This example demonstrates how to play raw audio data using QAudioSink from the PySide6 QtMultimedia module.
Audio Input (QAudioSource) Level Meter Example This example demonstrates how to capture raw audio data from a selected input device (e.g., microphone) using QAudioSource from the PySide6 QtMultimedia module.
Camera Application Example (QtMultimedia) This example demonstrates a full-featured camera application built using PySide6 and the QtMultimedia module. It showcases a comprehensive set of functionalities,
Media Player Example (QMediaPlayer) This example demonstrates how to build a basic media player application using PySide6 and the QtMultimedia module. It showcases the use of QMediaPlayer for audio and video playback, QVideoWidget for video rendering, and QAudioOutput for audio output.
Screen and Window Live Capture Example (QtMultimedia) This example demonstrates how to capture a live video feed of an entire screen or a specific window using QtMultimedia classes in PySide6.
Blocking Fortune Client Example (QTcpSocket in QThread) This example demonstrates how to create a simple TCP client that interacts with a "Fortune Server" (expected to be running separately). While the name suggests a "blocking" client, the example cleverly performs the blocking network operations (connecting and reading) within a separate worker thread (QThread) to keep the main GUI responsive.
Simple File Downloader Example (QNetworkAccessManager) This example demonstrates how to build a simple file downloader application using PySide6.
Asynchronous Fortune Client Example (QTcpSocket) This example demonstrates how to create an asynchronous TCP client using PySide6's QTcpSocket with Qt's signals and slots mechanism. The client connects to a "Fortune Server" (expected to be running separately), receives a fortune string, and displays it. All network operations are non-blocking, ensuring the User Interface (UI) remains responsive during connection attempts and data transfer.
Simple Fortune Server Example (QTcpServer) This example demonstrates how to create a basic, single-threaded TCP server using QTcpServer in PySide6. When a client connects, the server randomly selects a fortune string from a predefined list, sends it to the client, and then immediately closes the connection to that client.
Google Suggest Client with Custom SearchBox Example This example demonstrates how to create a custom search box (SearchBox, a QLineEdit subclass) that fetches and displays search suggestions from the Google Suggest service as the user types.
TCP Loopback Data Transfer Example This example demonstrates basic local TCP/IP communication within a single PySide6 application, simulating a data transfer benchmark. It uses QTcpServer to act as a server and QTcpSocket to act as a client, both connecting via the loopback interface (QHostAddress.LocalHost).
Threaded Fortune Server Example (QTcpServer with QThread) This example demonstrates how to create a multi-threaded TCP server using PySide6's QTcpServer and QThread. For each incoming client connection, the server spawns a new worker thread (FortuneThread) to handle all communication with that specific client. This allows the server to manage multiple client connections concurrently without blocking the main thread or other client interactions.
Reddit OAuth2 Client Example (QtNetworkAuth & QAbstractTableModel) This example demonstrates how to perform OAuth 2.0 authentication with the Reddit API using PySide6's QtNetworkAuth module. It covers the authorization code flow to obtain an access token. Once authenticated, the application fetches a list of "hot" threads from the Reddit API (/hot) and displays their titles in a QListView using a custom QAbstractTableModel (RedditModel).
OpenGL Context Information Example (QWindow with PyOpenGL) This example demonstrates how to initialize an OpenGL context within a QWindow subclass, render a simple animated 3D scene (a rotating colored triangle) using PyOpenGL, and query detailed information about the active OpenGL context. The QWindow containing the OpenGL scene is then embedded into a QWidget-based user interface using QWidget.createWindowContainer().
"Hello GL2" - Modern OpenGL Example with Shaders This example demonstrates basic 3D graphics rendering using modern, shader-based OpenGL (compatible with OpenGL 2.x features but using core profile concepts if available) within a PySide6 QOpenGLWidget.
3D Textured Cubes Example (Legacy OpenGL) This example demonstrates how to apply different textures to the faces of rotating 3D cubes using legacy OpenGL (fixed-function pipeline) within PySide6's QOpenGLWidget.
Threaded QOpenGLWidget Example This example demonstrates an advanced technique for performing OpenGL rendering in a separate worker thread while still using QOpenGLWidget for display in the main GUI thread. Instead of rendering to an offscreen Framebuffer Object (FBO) and passing a texture ID, this example transfers the QOpenGLWidget's own QOpenGLContext to a worker thread. The worker thread then makes this context current, performs OpenGL rendering directly (as if it were in the main thread), and then moves the context back to the GUI thread for QOpenGLWidget to compose and display the frame.
PDF Viewer Example This example demonstrates a Qt Quick PDF viewer application built using PySide6. It allows users to open and view PDF files, with features like scrolling, zooming, rotation, and text search.
PDF Viewer (QWidget) Example This example showcases a PDF viewer application built using PySide6 and the QWidget-based classes from the Qt PDF module. It allows users to open, view, and navigate PDF files.
QML Editable ListModel with Python Backend Example This example demonstrates how to create a custom list model in Python by subclassing QAbstractListModel (BaseModel class) and expose it for use in a QML interface. The QML side utilizes a ListView to display and interact with the data provided by this Python model. Each item in the list is visualized as a colored rectangle with text.
QML to Python Signal/Slot Example (qmltopy1) This example demonstrates how to call Python methods (slots) from QML, a fundamental aspect of integrating QML user interfaces with Python application logic in PySide6.
QML to Python with Return Value Example (qmltopy2) This example demonstrates how QML can call Python methods (slots) that return values, and how these return values can be used within the QML environment. It builds upon the basic concept of QML-to-Python communication.
Handling QML Signals in Python Example (qmltopy3) This example demonstrates how to define signals in QML and connect them to Python functions or lambda expressions. This allows Python logic to react to events and state changes occurring within the QML user interface.
Connecting Specific QML Object Signals to Python (qmltopy4) This example demonstrates how to connect a signal from a specific QML object, identified by its objectName, to a Python function or lambda. This is useful when you need to connect to signals of nested QML components rather than signals defined on the root QML item.
Python-QML Signal and Slot Interaction Examples This directory contains examples demonstrating various ways signals and slots can be used to communicate between Python and QML in a PySide6 application.
QML Text Properties Controlled by Python Functions This example demonstrates how a QML user interface can dynamically change the visual properties of a Text element (specifically its color, font size, and font styles like italic, bold, underline) by calling Python methods. A Python class (Bridge) is exposed to QML, providing slots that QML calls to retrieve calculated values. These return values are then used within QML's JavaScript handlers to update the properties of the QML Text element.
Extending QML Advanced - Adding Types Example This example demonstrates how to define a custom type in Python and make it available to QML as part of a QML module. It showcases loading a QML component that uses this custom Python type and interacting with its properties from Python.
Extending QML Advanced - Chapter 1: Base Project This example serves as the foundational project for an advanced tutorial series on extending QML with Python. It establishes a scenario involving a birthday party, defining custom QML types Person and BirthdayParty in Python, and demonstrating their usage in QML. Subsequent chapters in this tutorial series will build upon this base.
Extending QML Advanced - Chapter 2: Inheritance and Coercion This example is the second chapter in the advanced tutorial series on extending QML with Python. It builds upon the "Base-project" by demonstrating how to use class inheritance in Python to create specialized QML types and how QML handles these derived types through coercion when they are assigned to properties expecting a base type.
Extending QML Advanced - Chapter 3: Default Properties This example is the third chapter in the advanced tutorial series on extending QML with Python. It demonstrates how to define a "default property" for a custom QML type, allowing for more concise and natural syntax when declaring child objects in QML.
Extending QML Advanced - Chapter 4: Grouped Properties This example is the fourth chapter in the advanced tutorial series on extending QML with Python. It illustrates how to create and use "grouped properties" in QML by exposing an object as a property, whose own properties can then be set using a group syntax in QML.
Extending QML Advanced - Chapter 5: Attached Properties This example is the fifth chapter in the advanced tutorial series on extending QML with Python. It demonstrates how to create and use "attached properties" in QML, where a specific QML type can provide additional properties that can be "attached" to other QML objects, often within its scope or hierarchy.
Extending QML Advanced - Chapter 6: Property Value Source This example is the sixth and final chapter in the advanced tutorial series on extending QML with Python. It demonstrates how to create and use a "Property Value Source," a mechanism where a QML property's value is dynamically supplied by a custom Python class over time or based on specific logic.
Extending QML Advanced - Binding Example This example, part of the advanced tutorial series on extending QML with Python, focuses on the nuances of QML property bindings, particularly how they interact with Python-defined types and their notify signals. It builds upon the established "BirthdayParty" scenario.
Extending QML Advanced - Extension Objects Example This example demonstrates a powerful technique for extending existing C++ types (specifically Qt Widgets like QLineEdit) with new properties accessible from QML, without directly subclassing the C++ type. This is achieved by creating an "extension object" in Python.
Extending QML Advanced - Methods Example This example, part of the advanced tutorial series on extending QML with Python, focuses on exposing Python methods of custom QML types and calling these methods from QML. It uses the familiar "BirthdayParty" scenario.
Extending QML Advanced - Properties Example This example, part of the advanced tutorial series on extending QML with Python, provides a clear demonstration of defining and using object properties and list properties in Python custom types for QML consumption. It utilizes the "BirthdayParty" and "Person" concepts.
PySide6 QML Tutorials: Extending QML with Python - Advanced Concepts This directory contains a series of advanced examples demonstrating how to extend QML with Python in PySide6. Each sub-project focuses on specific techniques for exposing Python classes, properties, methods, and more complex behaviors to the QML environment.
Extending QML - Chapter 1: Basics This example is the first chapter in a tutorial series demonstrating how to extend QML with Python to create custom QML types. This chapter focuses on the fundamentals of defining a new QML type in Python, exposing its properties, and using it in a QML application.
Extending QML - Chapter 2: Methods and Signals This example is the second chapter in the tutorial series on extending QML with Python. It builds upon Chapter 1 by demonstrating how to add callable methods (slots) to a custom QML type defined in Python and how to emit signals from Python that can be handled in QML.
Extending QML - Chapter 3: Property Bindings This example is the third chapter in the tutorial series on extending QML with Python. It explains how to enable and use QML's powerful property binding mechanism for custom properties defined in Python QML types.
Extending QML - Chapter 4: Custom Property Types This example is the fourth chapter in the tutorial series on extending QML with Python. It demonstrates how to use a custom QML type, defined in Python, as the type for a property within another custom QML type.
Extending QML - Chapter 5: List Properties This example is the fifth chapter in the tutorial series on extending QML with Python. It demonstrates how to create and use list properties in custom QML types, enabling a component to manage a collection of other QML objects.
Extending QML - Chapter 6: Simulating Plugins This example is the sixth and final chapter in the tutorial series on extending QML with Python. It illustrates how to structure custom QML components written in Python in a way that mimics QML plugin deployment, making them reusable and importable as custom QML modules.
Python-QML Integration Tutorial Examples This directory contains a series of examples demonstrating various ways to extend QML with Python using PySide6. These tutorials cover exposing Python classes as QML types, defining properties, invoking methods (slots), handling signals, and structuring Python code as QML plugins.
Using a Python QAbstractListModel as a QML Singleton in ListView This example demonstrates how to expose a custom Python list model (subclassing QAbstractListModel) to QML as a singleton type and use it as the data source for a QML ListView. It shows how QML delegates can bind to the model's roles to display data.
Object List Model Example This example demonstrates how to use a Python list of QObject instances directly as a data model for QML views, such as ListView. This approach is often simpler than implementing a full QAbstractListModel for straightforward cases.
Python Models for QML Qt Quick Examples This directory contains examples demonstrating different ways to provide data from Python to QML Qt Quick views, specifically for use with items like ListView. These examples illustrate varying levels of complexity, from simple lists of strings or objects to more structured models.
String List Model Example This example demonstrates one of the simplest ways to provide data to QML views: using a Python list of strings directly as a data model for a QML ListView.
Custom QML Item with QQuickPaintedItem in Python (TextBalloon) This example demonstrates how to create a custom visual QML item using Python by subclassing QQuickPaintedItem. The custom item, TextBalloon, performs custom 2D drawing with QPainter in its paint() method to render a speech balloon shape. It also exposes a Python property (rightAligned) to QML that controls the orientation of the balloon's tail. The example further shows these custom items being used as delegates in a QML ListView and how new items can be dynamically added.
Qt Quick Render Control with Custom OpenGL (Textured Cube) This example demonstrates an advanced Qt Quick integration technique using QQuickRenderControl.
Custom OpenGL Rendering via QQuickWindow Signals in Qt Quick - "OpenGL Under QML" This example demonstrates an advanced technique for integrating custom OpenGL rendering directly into the Qt Quick scene using PyOpenGL. Instead of subclassing QQuickPaintedItem (for QPainter) or using QQuickFramebufferObject, this method involves a standard QQuickItem (Squircle) that connects to rendering signals of its containing QQuickWindow. A separate renderer class (SquircleRenderer) performs the actual OpenGL drawing operations during specific phases of the Qt Quick rendering loop (specifically, before Qt Quick records its own render passes for the main scene).
Custom Geometry in Qt Quick Scenegraph (BezierCurve) This example demonstrates how to create a custom visual QML item in Python (BezierCurve) that directly provides its graphical representation to the Qt Quick Scenegraph. This is achieved by subclassing QQuickItem and overriding the updatePaintNode() method. Inside this method, custom vertex geometry (QSGGeometry) for a Bezier curve and a simple material (QSGFlatColorMaterial) are defined and associated with a QSGGeometryNode. This allows for efficient rendering of custom shapes, with properties (like the Bezier curve's control points) exposed to and controllable by QML.
Qt Quick Windowing and Screen Information Example This example demonstrates various aspects of window management and screen information retrieval within a Qt Quick QML application using Python.
Custom Geometry for Qt Quick 3D via QQuick3DGeometry Subclassing This example demonstrates how to create custom 3D geometries for Qt Quick 3D scenes directly from Python. This is achieved by subclassing QQuick3DGeometry in Python and defining the vertex data (positions, normals, texture coordinates) and primitive types programmatically. These Python-defined custom geometry classes are then registered with QML using @QmlElement and can be directly assigned to the geometry property of a Model item in QML.
Introduction to Qt Quick 3D ("Intro") Example This example serves as a very basic "Hello World" for Qt Quick 3D in a PySide6 application. It demonstrates the fundamental setup of a 3D scene using QML,
Procedural Textures for Qt Quick 3D using Python QQuick3DTextureData This example demonstrates how to generate texture data procedurally in Python and apply it to 3D models in a Qt Quick 3D scene. It achieves this by creating a custom Python class (GradientTexture) that subclasses QQuick3DTextureData. This Python class programmatically generates raw pixel data (a linear gradient in this case) and makes it available to a QML Texture item.
QML Contacts List Application (Qt Quick Controls & Python Model) This example demonstrates building a contacts list application using QML with Qt Quick Controls for the user interface and a Python backend for data management.
QML File System Explorer (Qt Quick Controls & Python QFileSystemModel) This example demonstrates how to build a file system explorer application using QML with Qt Quick Controls.
Qt Quick Controls Gallery Example This application serves as a comprehensive gallery showcasing the various UI controls available in the Qt Quick Controls module (effectively Qt Quick Controls 2).
Qt Remote Objects - Model/View Example This example demonstrates how to share a Qt Item Model (specifically, a QStandardItemModel) between two separate Python processes using the Qt Remote Objects (QtRO) module.
Documentation for the Sample Bindings Example This directory contains detailed documentation resources that explain the C++ to Python binding generation process showcased in the samplebinding example. The main README.md for the complete example, including full build and run instructions, can be found in the parent directory.
PySide6 Custom C++ Binding Example ("samplebinding") This example demonstrates the process of creating Python bindings for a custom C++ library using PySide6's binding generation tool, Shiboken.
Documentation for the Scriptable Application Example This directory contains supplementary documentation for the "Scriptable Application" example.
Scriptable C++ Qt Application with Embedded Python This example demonstrates how to make a C++ Qt application scriptable by embedding a Python interpreter.
CAN Bus Communication Example (QtSerialBus) This example provides a graphical user interface (GUI) application built with PySide6 and QtWidgets for interacting with a Controller Area Network (CAN) bus using the QtSerialBus module.
Modbus Client Example (QtSerialBus) This example provides a graphical Modbus client application built with PySide6 and the QtSerialBus module.
Serial Port Terminal Example (QtSerialPort) This example demonstrates how to build a simple serial port terminal application using PySide6's QtSerialPort module and QtWidgets.
3D Spatial Audio Panning and Room Acoustics Example (QtSpatialAudio) This example demonstrates the capabilities of the QtSpatialAudio module in PySide6 for creating immersive 3D audio experiences.
Text-to-Speech ("Hello, Speak") Example (QTextToSpeech) This example demonstrates how to use the QTextToSpeech module in PySide6 to synthesize speech from text input.
SQL "Books" Database Example (QSqlRelationalTableModel) This example demonstrates a QtWidgets application in PySide6 for managing a database of books.
QSqlRelationalTableModel Example This example demonstrates the use of QSqlRelationalTableModel from PySide6's QtSql module to display and manage data from a database table that has foreign key relationships with other tables.
State Machine for Animating Block Movements ("Move Blocks") This example demonstrates a sophisticated use of the Qt State Machine Framework (QStateMachine, QState) in conjunction with Qt Animations (QPropertyAnimation, QParallelAnimationGroup, QSequentialAnimationGroup) to create complex, coordinated animations of multiple graphical items. Four QGraphicsRectWidget "blocks" move around a QGraphicsScene to various predefined geometric configurations.
Ping-Pong State Machine Example (Custom Events and Transitions) This example demonstrates a basic Qt State Machine (QStateMachine) that models a "ping-pong" behavior using custom events and transitions. It consists of two main conceptual states ("ping" and "pong") that effectively trigger each other. When one phase of the cycle occurs (e.g., "ping"), it prints a message and posts an event that, after a delay, triggers the other phase (e.g., "pong"), which then does likewise. This creates a continuous back-and-forth cycle, printing "ping?" and "pong!" to the console with a delay between them.
Simple Character-Based "Rogue-like" Movement with State Machine This example demonstrates using the Qt State Machine Framework (QStateMachine, QState) to manage basic interactions in a very simple, graphical "rogue-like" style application. The application displays a character-based map in a QMainWindow using QPainter. The player (represented by '@') can move around the map using keyboard input (numeric keys 2, 4, 6, 8).
Traffic Light State Machine Example This example demonstrates how to use the Qt State Machine Framework (QStateMachine, QState) to model the behavior of a traffic light system. It defines states that correspond to the Red, Green, and Yellow lights being active. Timed transitions, managed by QTimer objects encapsulated within custom state structures, control the sequence and duration of each light. A simple GUI, composed of custom-painted LightWidgets hosted in a TrafficLightWidget, visualizes the traffic light's current state.
Finance Manager Tutorial - Part 1: Basic UI, Data Model, and Entry This directory contains the first part of the Finance Manager tutorial series. This part focuses on setting up the basic application structure, including a QML user interface, a Python list-based data model for managing expenses, and functionality for displaying and adding new expense entries. A simple pie chart visualization is also introduced.
Finance Manager Tutorial - Part 2: Database Persistence with SQLAlchemy This directory contains the second part of the Finance Manager tutorial series. Building upon the foundation of Part 1, this part introduces database persistence for expense entries using SQLAlchemy ORM with an SQLite database.
Finance Manager Tutorial - Part 3: Client-Server Architecture with REST API This directory contains the third and final part of the Finance Manager tutorial series. This part significantly refactors the application into a client-server architecture. A Python backend server, built with FastAPI, provides a REST API to manage finance data, which is stored in an SQLite database using SQLAlchemy. The QML application (frontend) is updated so its FinanceModel interacts with this backend API via HTTP requests.
PySide6 Finance Manager Tutorial Example This example demonstrates the incremental development of a personal finance management application using PySide6, showcasing QML for the user interface and Python for the backend logic. The tutorial is divided into three parts, each building upon the previous one to introduce new features and concepts.
Dynamic UI Loading with QUiLoader from .ui File This example demonstrates how to dynamically load a user interface definition from an external Qt Designer (.ui) file at runtime using the QUiLoader class from the QtUiTools module in PySide6. It shows the basic steps to parse a .ui file and display the resulting widget hierarchy.
QWebChannel Standalone Example (WebSocket Communication) This example demonstrates bidirectional communication between a Python/Qt backend application and an HTML/JavaScript frontend (running in a standard web browser) using QWebChannel over a WebSocket connection. A Python QObject (the Core class) is exposed to the JavaScript environment.
QML Nano Browser Example (QtWebEngineQuick) This example demonstrates how to build a web browser application using QML and PySide6, leveraging the QtWebEngine module (specifically, WebEngineView from QtWebEngineQuick). It showcases a range of essential browser features,
Markdown Editor with Live Preview (QWebEngineView & QWebChannel) This example demonstrates how to build a Markdown editor application using PySide6.
WebEngine JavaScript Notification Handling with Custom Popups This example demonstrates how to handle and display JavaScript Web Notifications originating from a web page loaded in QWebEngineView.
Simple Browser Example (QtWebEngineWidgets) This example demonstrates how to build a tabbed web browser application using PySide6 with the QtWebEngineWidgets module. While named "simple", it showcases a range of common browser functionalities,
Widgets Nano Browser Example (QWebEngineView) This example demonstrates a very minimal web browser built using PySide6 and the QtWebEngineWidgets module. It showcases the fundamental use of QWebEngineView to display web pages within a QMainWindow.
QML Mini Browser Example (QtWebView) This example demonstrates how to build a very basic web browser application using QML and the QtWebView module from PySide6. It showcases the use of the WebView QML type for displaying web pages and includes essential UI controls.
Documentation for the Widget Binding Example This directory contains documentation specific to the widgetbinding example, primarily in the widgetbinding.md file.
C++ Custom Widget Binding ("WigglyWidget") Example
Animated Tiles Example (QStateMachine & QPropertyAnimation) This example demonstrates how to create a coordinated animation of multiple graphical items (tiles, represented by QGraphicsPixmapItems wrapped in custom Pixmap QObjects) using Qt's State Machine Framework and Property Animation system with PySide6.
Animated App Chooser Example (QStateMachine & QGraphicsView) This example demonstrates an animated application chooser interface using Qt's State Machine Framework (QStateMachine, QState) and Graphics View Framework (QGraphicsView, QGraphicsScene, QGraphicsWidget) with PySide6.
Easing Curves for Animations Example (QPropertyAnimation) This example demonstrates the visual effect of different easing curves (QEasingCurve) available in Qt when applied to QPropertyAnimation. Users can:
State Machine with Coordinated Animations Example This example demonstrates how to use the Qt State Machine Framework (QStateMachine, QState) in conjunction with the Animation Framework (QPropertyAnimation) to create complex, coordinated animations of multiple QGraphicsItems within a QGraphicsScene.
Desktop Screenshot Example (QScreen.grabWindow) This example demonstrates how to create a simple screenshot application using PySide6 and QtWidgets. The application allows users to:
System Tray Icon Example (QSystemTrayIcon) This example demonstrates how to integrate a PySide6 QtWidgets application with the system tray (also known as the notification area or status area on different operating systems). It showcases:
Class Wizard Example (QWizard) This example demonstrates how to create a multi-page wizard using QWizard and QWizardPage in PySide6. The wizard guides the user through a series of steps to collect information necessary for generating a skeleton Python class definition. It showcases several key wizard features:
Dialog with Expandable Extension Example This example demonstrates how to create a QDialog with an optional "extension" or "details" section that can be shown or hidden by the user at runtime. This is a common UI pattern for keeping a dialog simple by default while offering more advanced options or information on demand.
License Agreement Wizard Example (QWizard) This example demonstrates how to create a multi-page wizard using QWizard and QWizardPage in PySide6. The wizard simulates a software registration and evaluation process, guiding the user through a series of steps. It showcases features such as:
Qt Standard Dialogs Example (PySide6) This example demonstrates the use of various standard dialogs provided by Qt through PySide6. These dialogs offer common user interaction patterns for tasks such as:
Tabbed Dialog Example (QTabWidget in QDialog) This example demonstrates how to create a dialog box (QDialog) in PySide6 that organizes its content into multiple pages using a QTabWidget. The dialog is designed to display properties of a file or directory whose path is passed as a command-line argument.
Trivial Wizard Example (Basic QWizard) This example provides a minimal demonstration of the QWizard class in PySide6. It shows the fundamental structure of creating a wizard with a few sequential pages (QWizardPage). Each page in this trivial example simply displays a title and some basic content (like a QLabel or simple QLineEdits) to illustrate the most basic form of a multi-step wizard.
Draggable Icons Example (QDrag, QMimeData, Drag and Drop) This example demonstrates how to implement drag-and-drop functionality for QLabel widgets displaying icons within a PySide6 application. It showcases:
Draggable Text Example (QLabel, QDrag, QMimeData) This example demonstrates how to make individual text elements, represented by custom QLabel subclasses (DragLabel), draggable within a PySide6 application. It covers:
Drop Site Example This example demonstrates how to implement a custom widget in PySide6 that acts as a "drop site," capable of accepting drag and drop operations from other applications (or within the same application). It shows how to inspect the dropped data for various MIME types and display its content or a preview.
Blur Picker Effect Example This example demonstrates how to apply and dynamically adjust graphical effects, specifically QGraphicsBlurEffect, on items within a QGraphicsScene. It creates an interactive "picker" where icons are arranged in a circular fashion, and their blurriness changes based on their apparent depth, simulating a depth-of-field effect.
Lighting Effects Example This example demonstrates how to create a dynamic 2D scene with simulated lighting and shadow effects using PySide6's Graphics View Framework (QGraphicsView, QGraphicsScene). It features an animated light source and graphical items with drop shadows that respond realistically to the light's position and distance.
Internationalization with gettext Example This example demonstrates how to use the GNU gettext utilities and the Python gettext module for internationalizing a PySide6 Qt Widgets application. It shows how to mark strings for translation in Python code and load compiled message catalogs (.mo files) to display the UI in different languages.
Anchor Layout with QGraphicsView Example This example demonstrates the use of QGraphicsAnchorLayout to arrange widgets within a QGraphicsScene. It showcases how to create flexible, constraint-based layouts for items in a graphics view, similar to anchor-based layouts in QML.
Colliding Mice Example This example demonstrates a dynamic 2D graphical simulation using PySide6's Graphics View Framework (QGraphicsView, QGraphicsScene, QGraphicsItem). It features multiple animated "mouse" objects that move around a scene, interact with boundaries, and attempt to avoid collisions with each other.
Diagram Scene Example This example demonstrates a sophisticated interactive diagram editor built using PySide6's Graphics View Framework. Users can create, connect, and style various flowchart shapes and text items on a zoomable canvas.
Drag and Drop Robot Example This example demonstrates drag and drop operations within a QGraphicsScene using PySide6. It features draggable colored items and a multi-part robot character whose parts can change color or appearance based on what is dropped onto them. The robot is also animated.
Elastic Nodes Example This example demonstrates a dynamic, interactive graph visualization using PySide6's Graphics View Framework. It features nodes connected by edges that behave like elastic springs, creating a force-directed layout where nodes automatically adjust their positions to find a stable arrangement.
Image Viewer Example This example demonstrates a basic image viewer application built using PySide6 and Qt Widgets. It showcases functionalities such as opening, displaying, saving, printing, copying/pasting, and zooming images.
Address Book Example This example demonstrates a simple address book application built using PySide6 and Qt Widgets. It showcases the Model/View programming paradigm, specifically using QAbstractTableModel with QTableView and QSortFilterProxyModel to display and manage contacts.
Basic Sort/Filter Model Example This example demonstrates the use of QSortFilterProxyModel in PySide6 to provide sorting and filtering capabilities for data presented in item views like QTreeView. It shows how a proxy model can transform data from a source model before it's displayed, without altering the original data.
Dir View Example (QFileSystemModel) This example demonstrates how to use QFileSystemModel in conjunction with QTreeView to create a directory and file system viewer using PySide6. It provides a tree-based representation of the local file system, allowing users to browse directories and see files.
Editable Tree Model Example This example demonstrates how to create a custom, editable tree model in PySide6 by subclassing QAbstractItemModel and using it with a QTreeView. It allows for dynamic insertion and deletion of rows and columns, as well as editing of item data and headers.
Fetch More Example (Incremental Loading in Item Views) This example demonstrates how to use the "fetch more" mechanism in PySide6's Model/View framework to incrementally load data into a QAbstractListModel. This is particularly useful for displaying large datasets where loading all data at once would be inefficient or slow. The example simulates fetching a directory listing in batches.
JSON Model Example This example demonstrates how to parse JSON data, display it in a QTreeView using a custom QAbstractItemModel, and allow editing of the values. It provides a way to visualize and interact with hierarchical JSON structures.
SpinBox Delegate Example This example demonstrates how to use a custom delegate, specifically QStyledItemDelegate, to provide a QSpinBox as an editor for integer data within a QTableView. This allows users to edit numerical data in table cells using a spin box interface rather than a simple line edit.
Spreadsheet Example This example demonstrates a basic spreadsheet application built with PySide6. It showcases features like a custom table widget item for cell-specific behavior (including formula evaluation), a custom delegate for cell editing, and a main window with menus and a toolbar for user interaction.
Star Delegate Example This example demonstrates how to create a custom delegate (StarDelegate) in PySide6 to display and edit star ratings (e.g., 1 to 5 stars) within an item view, such as a QTableWidget. It involves custom painting for display and a custom widget for editing the rating.
Basic Layouts Example This example demonstrates the use of fundamental Qt layout managers in PySide6 to arrange widgets within a dialog. It showcases QHBoxLayout, QGridLayout, and QFormLayout, each used to structure a group of widgets.
Border Layout Example This example demonstrates how to implement a custom layout manager, BorderLayout, in PySide6. This layout class arranges child widgets in five distinct regions: North, South, East, West, and a central area, similar to the BorderLayout manager found in Java AWT/Swing.
Dynamic Layouts Example This example demonstrates how to dynamically change the layout of widgets within a PySide6 application at runtime. It showcases two main scenarios: re-arranging widgets within a grid and changing the orientation and position of a standard button box.
Flow Layout Example This example demonstrates how to implement a custom FlowLayout in PySide6. A flow layout arranges items horizontally in rows, similar to how words are arranged in a paragraph. If there isn't enough horizontal space in the current row for an item, it "flows" to the next row.
Qt Linguist Internationalization Example This example demonstrates how to use Qt's Linguist toolchain for internationalizing a PySide6 Qt Widgets application. It shows how to mark strings for translation, use .ts (translation source) and .qm (compiled Qt message) files, and load these translations at runtime using QTranslator.
Application Example (QMainWindow) This example demonstrates a simple yet functional text editor application built using PySide6's QMainWindow and other Qt Widgets. It showcases common features found in GUI applications, such as menus, toolbars, a status bar, file operations, clipboard integration, and settings persistence.
Dock Widgets Example This example demonstrates the use of QDockWidget within a QMainWindow to create a simple letter editing application. It showcases how dockable widgets can provide supplementary information or tools (like lists of customers and standard paragraphs) that interact with a central editing area.
MDI (Multiple Document Interface) Example This example demonstrates how to create a Multiple Document Interface (MDI) application using PySide6. In an MDI application, multiple document windows can be opened and managed within a single main window. This example implements a simple text editor where each document is an MdiChild window.
Basic Drawing Example (QPainter) This example demonstrates fundamental 2D drawing capabilities in PySide6 using the QPainter class. It showcases how to draw various shapes, lines, text, and pixmaps, and how to control their appearance using pens, brushes, and transformations.
Concentric Circles Example (QPainter) This example demonstrates basic 2D drawing with QPainter in PySide6, focusing on rendering concentric circles. It particularly highlights the visual differences produced by antialiasing and the use of floating-point versus integer precision for coordinates in drawing operations. The circles are also animated with a pulsing alpha (opacity) effect.
Painter Example (Basic Drawing Application) This example demonstrates a simple freehand drawing application built using PySide6 and Qt Widgets. It showcases how to use QPainter to draw on a QPixmap (acting as a canvas) in response to mouse events, and includes basic functionalities like saving/loading images, clearing the canvas, and changing the pen color.
Plot Example (QPainter and Opaque Containers) This example demonstrates how to create a simple animated plot using QPainter in PySide6. It draws a continuously shifting sine wave and specifically highlights the performance benefit of using "opaque containers" like QPointList when passing data to Qt drawing functions.
Simple RHI Widget Example This example demonstrates basic usage of Qt's Rendering Hardware Interface (RHI) within a PySide6 QWidget-based application. It shows how to render a simple animated 3D object (a colored triangle) using custom shaders via the RHI, embedded within a traditional widget UI.
Order Form Example (Rich Text Generation) This example demonstrates how to programmatically generate formatted documents (order form letters) using PySide6's rich text capabilities. It showcases the use of QTextEdit, QTextCursor, and various text formatting classes to construct a document based on user input from a dialog.
Syntax Highlighter Example This example demonstrates how to implement custom syntax highlighting in a PySide6 application using QSyntaxHighlighter. It creates a simple text editor (QPlainTextEdit) that applies different character formats to text patterns, recognizing basic Python-like syntax elements such as class and function definitions, and comments.
TextEdit Example (Rich Text Editor) This example implements a feature-rich text editor using PySide6's QTextEdit widget. It demonstrates advanced text formatting capabilities, including styles, lists, tables, image handling, and support for multiple file formats like HTML and Markdown.
Custom Text Object Example (Embedding SVGs) This example demonstrates how to embed custom objects, specifically SVG images, into a QTextDocument displayed by a QTextEdit in PySide6. This is achieved by implementing a custom text object handler using QPyTextObject (the Python binding for QTextObjectInterface).
Threading with Custom Signals Example This example demonstrates how to use QThread in PySide6 to perform tasks in a separate worker thread and safely communicate results or updates back to the main GUI thread using custom signals and slots. This is a fundamental pattern for keeping the user interface responsive during operations that might otherwise block it.
Regular Expression Example (QRegularExpression Tool) This example provides an interactive tool for testing and understanding Qt's QRegularExpression class in PySide6. It allows users to input a regular expression pattern, subject text, and various options, then displays detailed match information, captured groups, and the result of a replacement.
Qt Widgets Cannon Game Tutorial ("Cannon") This tutorial incrementally builds a simple 2D "cannon" game using PySide6 and the Qt Widgets module. Starting from basic widget creation, it progressively introduces concepts like custom widgets, layouts, signals and slots, custom painting with QPainter, event handling, animations with QTimer, and basic game logic including firing projectiles, collision detection, scoring, and game state management.
Qt Model/View Tutorial (PySide6 & QtWidgets) This tutorial series demonstrates the fundamentals of Qt's Model/View architecture using PySide6 with the QtWidgets module. The Model/View pattern is a powerful way to separate data management (models) from its presentation (views) and interaction (delegates, selections). These examples incrementally build up concepts, starting from a simple read-only table model and progressing to editable models, custom data formatting, headers, tree views, and selection handling.
Character Map Example This example implements a Character Map application using PySide6. It allows users to browse characters from different fonts, styles, and sizes, select characters, and insert them into a line edit or copy them to the clipboard. This is similar to standard character map utilities found in operating systems.
Digital Clock Example This example demonstrates how to create a simple digital clock widget using PySide6. It showcases the use of QLCDNumber for displaying time in an LCD-like format and QTimer for periodic updates.
Tetrix Game Example This example implements a classic Tetris-like game called "Tetrix" using PySide6 and Qt Widgets. It demonstrates custom widget painting for the game board and pieces, game logic implementation, event handling for user input (keyboard), and UI updates through signals and slots.
Widgets Gallery Example This example application, "Widget Gallery," serves as a comprehensive showcase of various common Qt Widgets available in PySide6. It displays a collection of widgets, allowing users to see their appearance and interact with them. A key feature is the ability to change the application style at runtime and observe how it affects the look and feel of the widgets.
DOM Bookmarks Example (XBEL Parser) This example demonstrates how to use PySide6's DOM (Document Object Model) classes from the QtXml module to read, parse, display, modify, and save XML documents. Specifically, it implements a reader and basic editor for XBEL (XML Bookmark Exchange Language) files, displaying the bookmark hierarchy in a QTreeWidget.
DOM Bookmarks Example (XBEL) This example demonstrates how to use Qt's XML module (specifically QDomDocument) to parse, display, modify, and save XML Bookmark Exchange Language (XBEL) files.