Copilot generated

Skip to content
Navigation Menu
Copilot

Copilot navigation
Copilot Chat
Porting Kotlin Glassmorphic UI to Python
You said: https://github.com/kirill-grouchnikov/artemis/blob/woodland/src/main/kotlin/org/pushingpixels/artemis/Glassmorphic.kt
https://github.com/kirill-grouchnikov/artemis/blob/woodland/src/main/kotlin/org/pushingpixels/artemis/Glassmorphic.kt
Copilot said: You've shared a link to the file
You've shared a link to the file Glassmorphic.kt in the woodland branch of the kirill-grouchnikov/artemis repository.

How can I assist you with this file? For example:

Do you want to see the file contents?
Are you looking for an explanation of the code?
Do you want to know about recent changes to this file?
Something else?
Please specify your request!

Glassmorphic.kt
You said: Can you port @kirill-grouchnikov/artemis/files/src/main/kotlin/org/pushingpixels/artemis/Glassmorphic.kt from kotlin to
Can you port @kirill-grouchnikov/artemis/files/src/main/kotlin/org/pushingpixels/artemis/Glassmorphic.kt from kotlin to python?
Copilot said: Certainly! Below is a clear, idiomatic port
Certainly! Below is a clear, idiomatic port of the provided Kotlin Jetpack Compose/Skia demo to Python, using PySide6 (Qt), PyQtGraph, and moderngl for shader/GLSL work, which are the closest Python tools for GUI, 2D graphics, and custom shaders.

Key notes about the port:

The Kotlin code uses Jetpack Compose (for UI), Skia (for vector graphics & shaders), and custom GLSL for glassmorphic effects.
In Python, the closest equivalents are PySide6 or PyQt5 for UI, Qt’s QPainter for 2D vector graphics, and moderngl or vispy for OpenGL/GLSL shaders.
The shader section is kept as a GLSL string and passed to the GL context.
Demo code focuses on the visual effect, not on exact window/control layout.
Some Compose specifics (like modifiers, density) are mapped to Qt equivalents (geometry, scaling).
You’ll need to install PySide6, PyQt5, and moderngl (or substitute with your preferred GL Python binding).

glassmorphic_demo.py
import sys
import numpy as np
from PySide6.QtWidgets import QApplication, QMainWindow, QWidget
from PySide6.QtGui import QPainter, QLinearGradient, QColor, QPen, QBrush, QFont, QPainterPath
from PySide6.QtCore import Qt, QRectF, QPointF

How to run:

Install dependencies:
bash
pip install PySide6
Save as glassmorphic_demo.py and run:
bash
python glassmorphic_demo.py
Notes:

This code visually mimics the colored shapes and glass border from the Kotlin Compose demo.
For full glassmorphic blur, Python currently requires more advanced OpenGL/GLSL (possible with moderngl or vispy), which can be added if you want the true blur+shader effect.
This port demonstrates the GUI, gradients, and layout; you can further extend it with shaders as needed.
If you need a version with moderngl (GLSL shader) integration for the blur/noise, let me know!

You said: Yes please
Yes please
Copilot said: ```python name=glassmorphic_moderngl.py import sys import numpy as np from PySide6.QtWidgets

glassmorphic_moderngl.py
import sys
import numpy as np
from PySide6.QtWidgets import QApplication, QMainWindow
from PySide6.QtCore import Qt
from PySide6.QtOpenGLWidgets import QOpenGLWidget
import moderngl
Instructions:

Install dependencies:

bash
pip install PySide6 moderngl numpy
Save as glassmorphic_moderngl.py and run:

bash
python glassmorphic_moderngl.py
What this does:

Opens a PySide6 window with a moderngl OpenGL widget.
Loads the original glassmorphic GLSL shader from the Kotlin sample.
Uses dummy (white) textures for content, blur, noise (can be replaced with real images or framebuffer captures for full effect).
To advance/extend:

Replace dummy textures with actual content, blur, and noise textures.
Overlay 2D painting for text and shapes using QPainter on top, or draw via OpenGL as well.
Tune rectangle/radius uniforms for your layout.
Let me know if you want a more detailed integration with text, gradients, or blur capture!

You said: Yes I want a more detailed integration
Yes I want a more detailed integration 
Copilot said: Absolutely! Here’s a detailed plan and a
Absolutely! Here’s a detailed plan and a Python file to get you started with a more complete glassmorphic effect, closely matching the Kotlin demo. This integration will:

Render the glassmorphic rectangle using your custom GLSL shader in moderngl
Render colored circles and gradients as in the original
Overlay crisp text and borders using Qt's QPainter on top of the GL shader output
Generate a real blur and some noise for the shader input by capturing the GL framebuffer and applying effects with numpy/scipy
Below is an example implementation, focusing on the integration of moderngl for the glassmorphic shader and QPainter for the text and borders.


glassmorphic_full_demo.py
import sys
import numpy as np
from PySide6.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout
from PySide6.QtCore import Qt, QRectF, QPointF, QSize
from PySide6.QtGui import QPainter, QColor, QLinearGradient, QPen, QBrush, QFont, QImage
from PySide6.QtOpenGLWidgets import QOpenGLWidget
Instructions:

Install dependencies:
bash
pip install PySide6 moderngl numpy scipy
Save the above as glassmorphic_full_demo.py and run:
bash
python glassmorphic_full_demo.py
What this does:

Renders the background and circles with QPainter → QImage → moderngl texture.
Applies Gaussian blur for the shader input.
Generates and uses a noise texture.
Runs your glassmorphic shader for the rectangle area.
Overlays border and all text using QPainter after the GL shader result.
Next steps:

You can tune rectangle/gradient/text parameters as needed.
For a fully dynamic demo (e.g., moving lights, animated noise), update on a timer.
Let me know if you want further refinement, more comments, or additional features!

You said: Why didn't you use skia-python for shading?
Why didn't you use skia-python for shading?
Copilot said: Great question! **skia-python** is indeed a
Great question!
skia-python is indeed a powerful library for 2D graphics and supports advanced features like shaders, blurs, gradients, and even custom SkSL (Skia Shading Language) just like the original Kotlin/Compose/Skia code.

Why the demo above used moderngl and Qt:

moderngl is a Python wrapper for OpenGL and is widely used for GLSL shader work.
PySide6/PyQt was chosen for its cross-platform GUI capabilities and easy text/gradient rendering.
At the time of writing, skia-python does not have as many high-level GUI integrations for windowing and input (which PyQt/PySide does), so it’s often combined with something else for full apps.
moderngl is also broadly documented for custom GLSL integration in Python.
However, you absolutely CAN use skia-python for this purpose!

skia-python supports runtime SkSL shaders and can load and run the exact same SkSL code as the original Kotlin sample.
It provides a Canvas API very similar to Jetpack Compose/Skia.
For a glassmorphic effect, you can:
Use skia-python’s ImageFilter for blur.
Use Shader and SkSL for the advanced compositing and noise.
Use Skia’s drawing primitives for circles, gradients, rounded rectangles, and text.
If you’d like, I can provide a skia-python equivalent demo for your glassmorphic card, running the SkSL shader nearly verbatim from the original Kotlin.

Would you like to see a glassmorphic card example using skia-python and SkSL?

You said: Yes, I would like to see a
Yes, I would like to see a glassmorphix card example using skia-python and SkSL.
Copilot said: Absolutely! Here is a practical example demonstrating
Absolutely! Here is a practical example demonstrating a glassmorphic card using skia-python and your original SkSL shader.

This example will:

Use skia-python for all rendering (background, glass card, text, gradients).
Use the SkSL runtime shader for the glassmorphic effect, just like your original Kotlin code.
Use PIL to generate a fractal noise texture (since Skia’s noise shader isn’t directly exposed in skia-python).
Draw everything to a window using skia-python’s built-in window functionality.

glassmorphic_skia.py
import skia
import numpy as np
from PIL import Image
import math

# ---- SkSL shader code from your original Kotlin/Compose ----
Instructions:

Install dependencies:
bash
pip install skia-python numpy pillow
Save the script as glassmorphic_skia.py.
Run it:
bash
python glassmorphic_skia.py
Open glassmorphic_card_skia.png to see the result!
What this does:

Uses skia-python to draw your card and run your SkSL glassmorphic shader, just like in Jetpack Compose/Skia.
Uses PIL+numpy to create a random RGB noise image for that noise texture.
Renders everything to a PNG image.
Notes:

For live GUI, you’d need to integrate with a windowing toolkit (like PyQt, Tkinter, or skia-python’s experimental window, or render repeatedly).
You can swap in your own noise, background, or texts as needed.
Let me know if you want a live interactive window or animation (possible, but a bit more setup)!

You said: Yes, i like to see a live
Yes, i like to see a live interactive window
Copilot said: Absolutely! Here’s a **live interactive window** example
Absolutely! Here’s a live interactive window example using skia-python and your SkSL shader, with PySide6 as the windowing backend so you have a modern window and can easily add further interactivity. This setup:

Uses skia-python for all drawing and shaders.
Uses your original SkSL code for the glassmorphic card.
Uses PySide6 for the window and event loop, showing the result live.
Renders at 60 FPS, making it easy to add simple animations later (e.g., moving circles, animated noise, etc.).

glassmorphic_live_skia.py
import sys
import math
import numpy as np
import skia
from PIL import Image
from PySide6.QtWidgets import QApplication, QWidget
How to run:

Install dependencies:
bash
pip install skia-python numpy pillow PySide6
Save as glassmorphic_live_skia.py
Run:
bash
python glassmorphic_live_skia.py
Result:
A live, interactive PySide6 window, rendering your glassmorphic card using Skia and your SkSL shader. The largest circle gently animates back and forth. You can add more animations/interactivity as desired!

Let me know if you’d like to see further customization, more interactivity, or how to add controls.

How can I help you?

Copilot said: Absolutely! Here’s a **live interactive window** example Absolutely! Here’s a live interactive window example using skia-python and your SkSL shader, with PySide6 as the windowing backend so you have a modern window and can easily add further interactivity. This setup: Uses skia-python for all drawing and shaders. Uses your original SkSL code for the glassmorphic card. Uses PySide6 for the window and event loop, showing the result live. Renders at 60 FPS, making it easy to add simple animations later (e.g., moving circles, animated noise, etc.). glassmorphic_live_skia.py import sys import math import numpy as np import skia from PIL import Image from PySide6.QtWidgets import QApplication, QWidget How to run: Install dependencies: bash pip install skia-python numpy pillow PySide6 Save as glassmorphic_live_skia.py Run: bash python glassmorphic_live_skia.py Result: A live, interactive PySide6 window, rendering your glassmorphic card using Skia and your SkSL shader. The largest circle gently animates back and forth. You can add more animations/interactivity as desired! Let me know if you’d like to see further customization, more interactivity, or how to add controls.

Author: HinTak

glassmorphic_demo.py

@@ -0,0 +1,82 @@
+import sys
+import numpy as np
+from PySide6.QtWidgets import QApplication, QMainWindow, QWidget
+from PySide6.QtGui import QPainter, QLinearGradient, QColor, QPen, QBrush, QFont, QPainterPath
+from PySide6.QtCore import Qt, QRectF, QPointF
+
+class GlassmorphicWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setMinimumSize(510, 370)
+        self.setWindowTitle("PySide6 Glassmorphic Demo")
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+
+        # Background
+        painter.fillRect(self.rect(), QColor("#03080D"))
+
+        # Draw blurred colored circles (approximate the shader-based effect)
+        # Circle 1 - Purple to Pink gradient
+        grad1 = QLinearGradient(QPointF(450, 60), QPointF(290, 190))
+        grad1.setColorAt(0, QColor(0x7A, 0x26, 0xD9))
+        grad1.setColorAt(1, QColor(0xE4, 0x44, 0xE1))
+        painter.setBrush(QBrush(grad1))
+        painter.setPen(Qt.NoPen)
+        painter.drawEllipse(QPointF(375, 125), 100, 100)
+
+        # Circle 2 - Solid Pink
+        painter.setBrush(QColor(0xEA, 0x35, 0x7C))
+        painter.drawEllipse(QPointF(100, 265), 55, 55)
+
+        # Circle 3 - Orange-Red gradient
+        grad2 = QLinearGradient(QPointF(180, 125), QPointF(230, 125))
+        grad2.setColorAt(0, QColor(0xEA, 0x33, 0x4C))
+        grad2.setColorAt(1, QColor(0xEC, 0x60, 0x51))
+        painter.setBrush(QBrush(grad2))
+        painter.drawEllipse(QPointF(205, 125), 25, 25)
+
+        # Glass rectangle border (mock glassmorphism with gradient stroke and alpha)
+        border_grad = QLinearGradient(QPointF(120, 110), QPointF(405, 290))
+        border_grad.setColorAt(0, QColor(255, 255, 255, 128))
+        border_grad.setColorAt(0.33, QColor(255, 255, 255, 0))
+        border_grad.setColorAt(0.66, QColor(0, 255, 72, 0))
+        border_grad.setColorAt(1, QColor(0, 255, 72, 128))
+        pen = QPen(QBrush(border_grad), 2)
+        painter.setPen(pen)
+        painter.setBrush(Qt.NoBrush)
+        rect = QRectF(86, 111, 318, 178)
+        painter.drawRoundedRect(rect, 20, 20)
+
+        # Text on paths
+        font = QFont("Arial", 14, QFont.Bold)
+        painter.setFont(font)
+        painter.setPen(QColor(255, 255, 255, 128))
+
+        def draw_text_path(text, y, size):
+            path = QPainterPath()
+            path.moveTo(100, y)
+            path.lineTo(400, y)
+            font.setPointSize(size)
+            painter.setFont(font)
+            painter.drawText(QPointF(102, y+size/2), text)
+
+        draw_text_path("MEMBERSHIP", 140, 14)
+        draw_text_path("JAMES APPLESEED", 240, 18)
+        draw_text_path("PUSHING-PIXELS", 265, 13)
+
+        # Optionally: add a glass blur effect (requires OpenGL/GLSL or Qt6's graphics effect)
+        # For a real glassmorphic effect, use a QGraphicsBlurEffect on a QGraphicsView,
+        # or use moderngl/vispy for a custom shader as in the original Kotlin.
+
+        painter.end()
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    win = QMainWindow()
+    widget = GlassmorphicWidget()
+    win.setCentralWidget(widget)
+    win.setWindowTitle("Glassmorphic Card UI - Python/PySide6")
+    win.show()
+    sys.exit(app.exec())

glassmorphic_full_demo.py

@@ -0,0 +1,224 @@
+import sys
+import numpy as np
+from PySide6.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout
+from PySide6.QtCore import Qt, QRectF, QPointF, QSize
+from PySide6.QtGui import QPainter, QColor, QLinearGradient, QPen, QBrush, QFont, QImage
+from PySide6.QtOpenGLWidgets import QOpenGLWidget
+import moderngl
+from scipy.ndimage import gaussian_filter
+
+def create_noise_texture(size):
+    # Generates a grayscale noise image.
+    noise = np.random.rand(size, size).astype(np.float32)
+    return (noise * 255).astype(np.uint8)
+
+def qimage_to_gl_texture(ctx, qimg):
+    # Converts QImage to an OpenGL texture for moderngl.
+    qimg = qimg.convertToFormat(QImage.Format_RGBA8888)
+    ptr = qimg.bits()
+    arr = np.array(ptr).reshape((qimg.height(), qimg.width(), 4))
+    return ctx.texture((qimg.width(), qimg.height()), 4, arr.tobytes())
+
+class GlassmorphicOpenGLWidget(QOpenGLWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.ctx = None
+        self.prog = None
+        self.vao = None
+        self.tex_content = None
+        self.tex_blur = None
+        self.tex_noise = None
+        self.framebuffer_data = None
+
+    def initializeGL(self):
+        self.ctx = moderngl.create_context()
+        self.setMinimumSize(510, 370)
+
+        # Compile shaders
+        self.prog = self.ctx.program(
+            vertex_shader="""
+                #version 330
+                in vec2 in_vert;
+                out vec2 v_text;
+                void main() {
+                    v_text = in_vert;
+                    gl_Position = vec4((in_vert - 0.5) * 2.0, 0.0, 1.0);
+                }
+            """,
+            fragment_shader="""
+                #version 330
+                uniform sampler2D content;
+                uniform sampler2D blur;
+                uniform sampler2D noise;
+                uniform vec4 rectangle;
+                uniform float radius;
+                uniform float dropShadowSize;
+                in vec2 v_text;
+                out vec4 f_color;
+                float roundedRectangleSDF(vec2 position, vec2 box, float radius) {
+                    vec2 q = abs(position) - box + vec2(radius);
+                    return min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - radius;
+                }
+                void main() {
+                    vec2 coord = v_text;
+                    vec2 shiftRect = (rectangle.zw - rectangle.xy) / 2.0;
+                    vec2 shiftCoord = coord - rectangle.xy;
+                    float distanceToClosestEdge = roundedRectangleSDF(
+                        shiftCoord - shiftRect, shiftRect, radius);
+                    vec4 c = texture(content, coord);
+                    if (distanceToClosestEdge > 0.0) {
+                        if (distanceToClosestEdge < dropShadowSize) {
+                            float darkenFactor = (dropShadowSize - distanceToClosestEdge) / dropShadowSize;
+                            darkenFactor = pow(darkenFactor, 1.6);
+                            f_color = c * (0.9 + (1.0 - darkenFactor) / 10.0);
+                            return;
+                        }
+                        f_color = c;
+                        return;
+                    }
+                    vec4 b = texture(blur, coord);
+                    vec4 n = texture(noise, coord);
+                    float lightenFactor = min(1.0, length(coord - rectangle.xy) / (0.85 * length(rectangle.zw - rectangle.xy)));
+                    float noiseLuminance = dot(n.rgb, vec3(0.2126, 0.7152, 0.0722));
+                    lightenFactor = min(1.0, lightenFactor + noiseLuminance);
+                    f_color = b + (vec4(1.0) - b) * (0.35 - 0.25 * lightenFactor);
+                }
+            """
+        )
+
+        # Fullscreen quad
+        vertices = np.array([
+            0.0, 0.0,
+            1.0, 0.0,
+            0.0, 1.0,
+            1.0, 1.0,
+        ], dtype='f4')
+        vbo = self.ctx.buffer(vertices.tobytes())
+        self.vao = self.ctx.simple_vertex_array(self.prog, vbo, 'in_vert')
+
+        # Prepare textures (dummy, will be updated in paintGL)
+        self.tex_content = self.ctx.texture((self.width(), self.height()), 4)
+        self.tex_blur = self.ctx.texture((self.width(), self.height()), 4)
+        noise_data = create_noise_texture(max(self.width(), self.height()))
+        self.tex_noise = self.ctx.texture((noise_data.shape[1], noise_data.shape[0]), 1, noise_data.tobytes())
+        self.tex_noise.build_mipmaps()
+        self.tex_noise.repeat_x = True
+        self.tex_noise.repeat_y = True
+
+    def paintGL(self):
+        # Render colored circles/gradients to an offscreen QImage (content texture)
+        qimg = QImage(self.width(), self.height(), QImage.Format_RGBA8888)
+        qimg.fill(QColor(3, 8, 13, 255))  # bg
+        painter = QPainter(qimg)
+        painter.setRenderHint(QPainter.Antialiasing)
+
+        # Draw the colored circles to QImage
+        grad1 = QLinearGradient(QPointF(450, 60), QPointF(290, 190))
+        grad1.setColorAt(0, QColor(0x7A, 0x26, 0xD9))
+        grad1.setColorAt(1, QColor(0xE4, 0x44, 0xE1))
+        painter.setBrush(QBrush(grad1))
+        painter.setPen(Qt.NoPen)
+        painter.drawEllipse(QPointF(375, 125), 100, 100)
+
+        painter.setBrush(QColor(0xEA, 0x35, 0x7C))
+        painter.drawEllipse(QPointF(100, 265), 55, 55)
+
+        grad2 = QLinearGradient(QPointF(180, 125), QPointF(230, 125))
+        grad2.setColorAt(0, QColor(0xEA, 0x33, 0x4C))
+        grad2.setColorAt(1, QColor(0xEC, 0x60, 0x51))
+        painter.setBrush(QBrush(grad2))
+        painter.drawEllipse(QPointF(205, 125), 25, 25)
+
+        painter.end()
+
+        # Convert QImage to moderngl texture for content
+        self.tex_content.release()
+        self.tex_content = qimage_to_gl_texture(self.ctx, qimg)
+        self.tex_content.use(location=0)
+
+        # Create a blurred version (using numpy + scipy)
+        arr = np.array(qimg.bits(), dtype=np.uint8).reshape((self.height(), self.width(), 4))
+        arr_blur = gaussian_filter(arr.astype(np.float32), sigma=(15, 15, 0))
+        arr_blur = np.clip(arr_blur, 0, 255).astype(np.uint8)
+        qimg_blur = QImage(arr_blur.data, self.width(), self.height(), QImage.Format_RGBA8888)
+        self.tex_blur.release()
+        self.tex_blur = qimage_to_gl_texture(self.ctx, qimg_blur)
+        self.tex_blur.use(location=1)
+
+        # Noise texture (already set up)
+        self.tex_noise.use(location=2)
+
+        # Shader uniforms (rectangle as normalized coords)
+        x1, y1, x2, y2 = 85, 110, 405, 290
+        nx1, ny1 = x1 / self.width(), y1 / self.height()
+        nx2, ny2 = x2 / self.width(), y2 / self.height()
+        self.prog['rectangle'].value = (nx1, ny1, nx2, ny2)
+        self.prog['radius'].value = 20 / self.width()
+        self.prog['dropShadowSize'].value = 15 / self.width()
+        self.prog['content'].value = 0
+        self.prog['blur'].value = 1
+        self.prog['noise'].value = 2
+
+        self.ctx.clear(0.015, 0.03, 0.05, 1.0)
+        self.vao.render(moderngl.TRIANGLE_STRIP)
+
+        # Save the framebuffer for later use in overlay painting
+        data = self.ctx.screen.read(components=4, alignment=1)
+        self.framebuffer_data = np.frombuffer(data, dtype=np.uint8).reshape((self.height(), self.width(), 4))
+
+    def paintEvent(self, event):
+        # Paint the GL result, then QPainter overlays
+        super().paintEvent(event)
+        painter = QPainter(self)
+        if self.framebuffer_data is not None:
+            # Draw the GL framebuffer as a QImage
+            qimg = QImage(self.framebuffer_data.data, self.width(), self.height(), QImage.Format_RGBA8888)
+            painter.drawImage(0, 0, qimg)
+
+        # Draw glassmorphic border and text overlays
+        border_grad = QLinearGradient(QPointF(120, 110), QPointF(405, 290))
+        border_grad.setColorAt(0, QColor(255, 255, 255, 128))
+        border_grad.setColorAt(0.33, QColor(255, 255, 255, 0))
+        border_grad.setColorAt(0.66, QColor(0, 255, 72, 0))
+        border_grad.setColorAt(1, QColor(0, 255, 72, 128))
+        pen = QPen(QBrush(border_grad), 2)
+        painter.setPen(pen)
+        painter.setBrush(Qt.NoBrush)
+        rect = QRectF(86, 111, 318, 178)
+        painter.drawRoundedRect(rect, 20, 20)
+
+        font = QFont("Arial", 14, QFont.Bold)
+        painter.setFont(font)
+        painter.setPen(QColor(255, 255, 255, 128))
+        painter.drawText(QPointF(102, 150), "MEMBERSHIP")
+
+        font.setPointSize(18)
+        painter.setFont(font)
+        painter.drawText(QPointF(102, 250), "JAMES APPLESEED")
+
+        font.setPointSize(13)
+        painter.setFont(font)
+        painter.drawText(QPointF(102, 275), "PUSHING-PIXELS")
+
+        painter.end()
+
+    def resizeGL(self, w, h):
+        # Force update of noise and textures
+        pass
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Glassmorphic Card - Full Demo")
+        self.setGeometry(100, 100, 510, 370)
+        central = QWidget()
+        layout = QVBoxLayout(central)
+        self.gl_widget = GlassmorphicOpenGLWidget(self)
+        layout.addWidget(self.gl_widget)
+        self.setCentralWidget(central)
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    win = MainWindow()
+    win.show()
+    sys.exit(app.exec())