Building Desktop Applications in Python - GeeksforGeeks

Building Desktop Applications in Python

Last Updated : 5 Oct, 2026

Python provides several libraries and frameworks for creating desktop applications with graphical user interfaces (GUIs). These tools allow developers to build applications with windows, buttons, menus, forms, and other interactive elements.

It provides several frameworks for building graphical desktop applications.

  • Tkinter: Simple desktop applications and beginner projects.
  • PyQt/PySide: Feature-rich and professional desktop applications.
  • Kivy: Cross-platform applications, including mobile applications.
  • wxPython: Applications that require native-looking interface components.

Installation and Environment Setup

Before creating a desktop application, Python and the required development tools should be available on the system.

Installing GUI Libraries

Some libraries are included with python, while other need to be installed separately.

pip install PyQt5

Similarly other frameworks are included with python, while other need to be installed separately.

Setting up Virtual Environment

A virtual environment keeps project dependencies isolated from other Python projects.

  • Create a virtual environment using:

python -m venv venv

  • Activate it according to your operating system.

For more information on Virtual Environment, please refer to our article on Python Virtual Environment.

import tinkter as tk

from tkinter import messagebox

Explanation:

  • tinkter provides the GUI components used by the application.
  • messagebox is used to display warning messages.

2. Creating Main Application Window

Python 
root = tk.TK()

root.title("To-Do-List")

root.geometry("300x400")

Explanation:

  • tk.TK() creates the main application window.
  • title() sets the title displayed on the window.
  • geometry() defines the initial width and height of the window.

3. Adding Widgets and Handle Events

Storing Tasks in a List

tasks = [ ]

The tasks list stores that tasks entered by the user during the current application session.

Function to add task

Python 
def add_task():
    """Adds a task to the list."""
    task = task_entry.get() 
    
    if task:
        tasks.append(task)
        task_listbox.insert(tk.END, task)
        task_entry.delete(0, tk.END)
    else:
        messagebox.showwarning("Warning", "Task cannot be empty")

Explanation:

  • get() retrieves the text entered by the user.
  • append() stores the task in the tasks list.
  • insert() displays the task in the Listbox.
  • delete() clears the input field after adding a task.
  • showwarning() displays a warning when the input field is empty.

Function to Remove a Task

Python 
def remove_task():
    """Removes selected task from the list."""
    try:
        selected_task_index = task_listbox.curselection()[0] 
        task_listbox.delete(selected_task_index)
        del tasks[selected_task_index]
    except IndexError:
        messagebox.showwarning("Warning", "No task selected!")

Explanation:

  • curselection() gets the currently selected task.
  • delete() removes the selected item from the Listbox.
  • del removes the same task from the tasks list.
  • IndexError is handled when the user tries to remove a task without selecting one.

Creating Input Field, Buttons and Tasks List

Python 
task_entry = tk.Entry(root, width=30)
task_entry.pack(pady=10)

add_button = tk.Button(root, text="Add Task", command=add_task)
add_button.pack()

remove_button = tk.Button(root, text="Remove Task", command=remove_task)
remove_button.pack()

task_listbox = tk.Listbox(root, width=40, height=15)
task_listbox.pack(pady=10)

Explanation:

  • Entry creates the field used to enter a task.
  • Button creates controls for adding and removing tasks.
  • Listbox displays all added tasks.
  • command connects a button with its corresponding function.
  • pack() places the widgets inside the application window.

4. Run the Application

Python 
root.mainloop()

Explanation:

  • mainloop() starts Tkinter's event loop.
  • Application waits for user actions such as button clicks.
  • Interface continues processing events until the window is closed.

Complete Code

Python 
import tkinter as tk
from tkinter import messagebox

root = tk.Tk()
root.title("To-Do List") 
root.geometry("300x400") 

tasks = []

def add_task():
    """Adds a task to the list."""
    task = task_entry.get() 
    if task:
        tasks.append(task) 
        task_listbox.insert(tk.END, task)
        task_entry.delete(0, tk.END)
    else:
        messagebox.showwarning("Warning", "Task cannot be empty!")

def remove_task():
    """Removes selected task from the list."""
    try:
        selected_task_index = task_listbox.curselection()[0] 
        task_listbox.delete(selected_task_index) 
        del tasks[selected_task_index]
    except IndexError:
        messagebox.showwarning("Warning", "No task selected!") 


task_entry = tk.Entry(root, width=30) 
task_entry.pack(pady=10) 

add_button = tk.Button(root, text="Add Task", command=add_task) 
add_button.pack()  

remove_button = tk.Button(root, text="Remove Task", command=remove_task) 
remove_button.pack() 

task_listbox = tk.Listbox(root, width=40, height=15)
task_listbox.pack(pady=10)


root.mainloop()

Output

output
To Do List

Best Practices

Building a desktop application requires clean code, performance optimization, and a great user experience. Here are key practices to follow:

  • Keep the GUI, business logic, and database code separate.
  • Use virtual environments (venv or conda) to isolate project dependencies.
  • Use multithreading or asynchronous operations for time-consuming tasks.
  • Implement exception handling and logging for easier debugging.
  • Run background tasks separately and provide user feedback through progress indicators.
  • Use databases such as SQLite instead of plain text files for persistent storage.
  • Create distributable executables using tools like PyInstaller.
  • Validate functionality through testing and debugging before deployment.
Comment

Explore