Create desktop widgets with Python

Creating desktop widgets with Python is a powerful way to build lightweight, always-on-top applications for displaying useful information like weather updates, system stats, calendars, or custom reminders. With the right libraries, you can create stylish, interactive widgets that run on Windows, macOS, and Linux desktops.

Choosing the Right Library for Desktop Widgets

Several GUI libraries are available in Python, but not all are ideal for building compact, always-on-top widgets. The most suitable options include:

• Tkinter (built-in, cross-platform, lightweight)

• PyQt5 / PySide2 or PyQt6 / PySide6 (feature-rich, customizable, modern UI)

• Kivy (good for multi-touch and mobile apps but overkill for simple widgets)

• wxPython (cross-platform with native look and feel)

For simplicity and cross-platform compatibility, Tkinter or PyQt5 are the most popular choices for desktop widgets.

Creating a Basic Desktop Widget with Tkinter

Here’s how to build a simple, always-on-top clock widget using Tkinter:

python
CopyEdit
import tkinter as tk
import time

def update_time():
    current_time = time.strftime('%H:%M:%S')
    label.config(text=current_time)
    root.after(1000, update_time)

root = tk.Tk()
root.title("Clock Widget")
root.geometry("200x100")
root.resizable(False, False)
root.attributes("-topmost", True)
root.configure(bg="black")

label = tk.Label(root, font=('Helvetica', 40), fg='lime', bg='black')
label.pack(expand=True)

update_time()
root.mainloop()

Key Features:

• Uses attributes("-topmost", True) to keep the widget on top.

• Auto-updates every second using after.

• Simple black-and-green digital clock aesthetic.

Creating Advanced Widgets with PyQt5

PyQt5 allows for more flexibility and better visuals. Here’s an example of a weather widget using a placeholder:

python
CopyEdit
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QVBoxLayout
from PyQt5.QtCore import Qt, QTimer, QTime

class ClockWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
        self.setFixedSize(250, 100)
        self.setStyleSheet("background-color: #1e1e1e; color: #00ff00; font-size: 28px;")
        
        self.label = QLabel()
        self.label.setAlignment(Qt.AlignCenter)

        layout = QVBoxLayout()
        layout.addWidget(self.label)
        self.setLayout(layout)

        timer = QTimer(self)
        timer.timeout.connect(self.update_time)
        timer.start(1000)
        self.update_time()

    def update_time(self):
        current_time = QTime.currentTime().toString('hh:mm:ss')
        self.label.setText(current_time)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    widget = ClockWidget()
    widget.show()
    sys.exit(app.exec_())

Features:

• Frameless, sleek interface.

• Always-on-top using Qt.WindowStaysOnTopHint.

• Easily extendable to show other data like weather, CPU usage, etc.

Making Widgets Transparent

To make widgets look more like native desktop elements, transparency helps. For Tkinter, transparency support is limited and platform-dependent, but in PyQt5, it’s straightforward:

python
CopyEdit
self.setAttribute(Qt.WA_TranslucentBackground)
self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)

You can also round corners or apply shadow effects using QGraphicsDropShadowEffect or CSS-like stylesheets.

Adding Interactivity

You can add buttons, sliders, or custom signals/slots in PyQt5 widgets for interactive functionality. Example use cases:

• Sticky Notes: Editable text areas with save/load functionality.

• System Monitor: Display CPU, RAM, disk stats with psutil.

• Weather Widgets: Fetch real-time weather data using an API like OpenWeatherMap.

• To-do Lists: Add task management features with persistent storage using SQLite or JSON.

Using External Data and APIs

To fetch live data, integrate widgets with REST APIs. Here’s a minimal weather display example using the requests library and OpenWeatherMap API:

python
CopyEdit
import requests

def get_weather(city, api_key):
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        temp = data['main']['temp']
        description = data['weather'][0]['description']
        return f"{city}: {temp}°C, {description}"
    else:
        return "Failed to get weather data"

You can integrate this function into your widget’s update cycle to show real-time weather.

System Tray Widgets

For persistent widgets without cluttering the desktop, system tray integration is valuable. PyQt5 allows you to create tray icons with popup menus:

python
CopyEdit
from PyQt5.QtWidgets import QSystemTrayIcon, QMenu, QAction
from PyQt5.QtGui import QIcon

tray = QSystemTrayIcon(QIcon("icon.png"))
menu = QMenu()
exit_action = QAction("Exit")
exit_action.triggered.connect(app.quit)
menu.addAction(exit_action)
tray.setContextMenu(menu)
tray.show()

This can hide the main window and allow users to toggle it from the tray icon.

Packaging the Widget as a Standalone App

Once your widget is ready, use tools like PyInstaller or cx_Freeze to convert the script into an executable.

Example with PyInstaller:

bash
CopyEdit
pyinstaller --noconfirm --onefile --windowed widget.py

Options:

• --windowed hides the terminal on Windows/macOS.

• --onefile creates a single executable.

Ensure all dependencies are included, and for PyQt5, you might need to specify hidden imports.

Tips for Optimizing Desktop Widgets

• Keep resource usage low; avoid blocking calls.

• Use QTimer or Tkinter’s after() instead of infinite loops.

• Apply minimalistic UI for better UX.

• Allow drag-and-drop or repositioning on the desktop.

• Add right-click or double-click events for quick actions.

Common Use Cases

• Clocks and Calendars

• Reminders and Sticky Notes

• Weather and Air Quality Monitors

• Cryptocurrency Price Trackers

• Music/Media Controls

• Live News or RSS Feeds

• System Performance Widgets

Conclusion

Creating desktop widgets in Python is both accessible and flexible. Whether you prefer the simplicity of Tkinter or the customization capabilities of PyQt5, Python allows you to build cross-platform, beautiful widgets with minimal overhead. By combining GUI frameworks with APIs and clever design, you can develop lightweight tools that significantly enhance desktop productivity and aesthetics.