Learn How to Build a Desktop Program in Python: Absolute Beginners Tutorial

Python is not only a scripting language — it can produce real desktop programs with windows, buttons, and input fields that run on any platform. The standard library includes tkinter, a toolkit that gives you everything needed to build a functioning GUI application without installing anything extra.

This tutorial walks through building a working desktop application from scratch. By the end you will have a functional tip calculator — a small but complete program with a window, labeled inputs, a button, and a live result display. Every concept introduced here is transferable to any tkinter project you build after this one.

What is tkinter and Why Use It

tkinter is Python's standard GUI library. It wraps a toolkit called Tk, which has been maintained since the late 1980s and runs on Windows, macOS, and Linux without modification. Because tkinter ships with CPython, you do not need to run pip install for anything in this tutorial. On most Linux distributions you may need to install the separate package — on Debian and Ubuntu that command is sudo apt install python3-tk.

The Python documentation describes tkinter as providing "a thin object-oriented layer on top of Tcl/Tk." In practice that means every visual element — a button, a label, a text field — is a Python object with methods and attributes. You configure them in Python, and tkinter handles the platform-level drawing.

For absolute beginners, tkinter is a practical starting point because it introduces GUI concepts (windows, events, widgets) without requiring you to learn a framework with its own file structure, build pipeline, or package manager. The tradeoff is that the default widget appearance is plain. Libraries such as CustomTkinter and ttkthemes extend tkinter with styled widgets while keeping the same programming model covered here.

Your First Window in Five Lines

The minimal tkinter program creates a window, gives it a title, and starts the event loop. Run the code below and a blank window will open on your screen.

import tkinter as tk

root = tk.Tk()
root.title("My First Window")
root.geometry("400x300")
root.mainloop()

Walking through each line: import tkinter as tk loads the library and gives it the short alias tk, which is the convention you will see everywhere. tk.Tk() creates the root window — there is exactly one root window in a tkinter application. .title() sets the text that appears in the window's title bar. .geometry("400x300") sets the initial width and height in pixels. root.mainloop() starts the event loop and must be the last line in your script.

Widgets: Labels, Buttons, and Entry Fields

A window with nothing in it is just a container. Widgets are the elements that make a program usable — text, buttons, input boxes, checkboxes, menus. Every widget is a Python class in tkinter. You create an instance, configure it, and then call a geometry manager to make it appear.

Label

A Label displays static text or an image. It does not respond to user input — it is purely for showing information.

label = tk.Label(root, text="Enter the bill amount:")
label.pack(pady=8)

Entry

An Entry widget accepts a single line of text from the user. To read what the user typed, use a StringVar bound to the widget via the textvariable parameter, then call .get() on the variable.

bill_var = tk.StringVar()
entry = tk.Entry(root, textvariable=bill_var, width=20)
entry.pack(pady=4)

# Later, inside a function:
value = bill_var.get()   # returns the current text as a string

Button

A Button runs a function when clicked. Pass the function using the command keyword — without parentheses, otherwise the function runs immediately when the window opens rather than when the button is clicked.

def calculate():
    print("Button clicked")

btn = tk.Button(root, text="Calculate Tip", command=calculate)
btn.pack(pady=10)

Geometry Managers: pack, grid, and place

Creating a widget does not make it visible. You must call one of the three geometry managers to position it inside the window. Mixing geometry managers within the same container causes conflicts — pick one and use it consistently.

pack is the simplest manager. It stacks widgets in a line, top to bottom by default. Use the side parameter (tk.LEFT, tk.RIGHT, tk.TOP, tk.BOTTOM) and the pady / padx parameters for spacing.

grid places widgets in an invisible table of rows and columns. It is well suited for forms where labels and inputs need to line up. Use row= and column= keyword arguments.

place positions widgets at exact x/y pixel coordinates. This gives full control but makes layouts fragile when the window is resized. It is rarely the right choice for beginners.

# grid example — label in column 0, entry in column 1
tk.Label(root, text="Bill amount ($):").grid(row=0, column=0, sticky="e", padx=8, pady=6)
bill_entry.grid(row=0, column=1, padx=8, pady=6)

tk.Label(root, text="Tip percentage:").grid(row=1, column=0, sticky="e", padx=8, pady=6)
tip_entry.grid(row=1, column=1, padx=8, pady=6)

The complete tip calculator source code puts everything together:

import tkinter as tk

def calculate_tip():
    try:
        bill   = float(bill_var.get())
        pct    = float(tip_var.get())
        tip    = bill * (pct / 100)
        total  = bill + tip
        result_var.set(f"Tip: ${tip:.2f}   Total: ${total:.2f}")
    except ValueError:
        result_var.set("Please enter valid numbers.")

root = tk.Tk()
root.title("Tip Calculator")
root.geometry("320x220")
root.resizable(False, False)

bill_var   = tk.StringVar()
tip_var    = tk.StringVar(value="15")
result_var = tk.StringVar()

tk.Label(root, text="Bill amount ($):").grid(row=0, column=0, sticky="e", padx=10, pady=6)
tk.Entry(root, textvariable=bill_var, width=14).grid(row=0, column=1, padx=10, pady=6)

tk.Label(root, text="Tip percentage:").grid(row=1, column=0, sticky="e", padx=10, pady=6)
tk.Entry(root, textvariable=tip_var, width=14).grid(row=1, column=1, padx=10, pady=6)

tk.Button(root, text="Calculate", command=calculate_tip).grid(
    row=2, column=0, columnspan=2, pady=12)

tk.Label(root, textvariable=result_var, fg="#2ecc71").grid(
    row=3, column=0, columnspan=2)

root.mainloop()

"Simple is better than complex." — The Zen of Python, Tim Peters

Python Learning Summary Points

1. tkinter is Python's built-in GUI toolkit. It ships with CPython on Windows and macOS and requires a single package install on most Linux distributions. No third-party dependencies are needed to get started.
2. Every visible element in a tkinter program is a widget — an instance of a class like Label, Entry, or Button. Widgets must be attached to a parent window or frame and positioned with a geometry manager before they become visible.
3. The three geometry managers are pack (linear stacking), grid (row/column table), and place (exact coordinates). Never mix pack and grid within the same parent container.
4. Event-driven programming means the program waits for user actions rather than running top to bottom. Functions tied to widgets through the command parameter are called event handlers. Pass function names without parentheses so tkinter can call them later.
5. StringVar and the other tkinter variable types (IntVar, DoubleVar, BooleanVar) keep Python variables and widget displays synchronized. Use .get() to read values and .set() to update them without rebuilding the widget.

Building a GUI program reinforces core Python skills — functions, exception handling, string formatting, and object instantiation — while producing something immediately tangible. Once you are comfortable with the tip calculator structure, applying the same pattern to other tools is straightforward: swap in different widgets, add more fields, or wrap the layout in frames to organize complex interfaces.