🎲 Build a Random Username Generator in Python with Tkinter

In this tutorial, we’ll build a Random Username Generator using Python, Tkinter, and threading. The app allows users to generate usernames in different styles, filter, sort, and copy them easily.

We’ll break it into digestible steps for beginners.

1️⃣ Setting Up the Project

First, create a new Python file called username_generator.py and make sure you have Python 3.9+ installed.

We’ll import all the libraries we need:

import os
import json
import random
import string
import tkinter as tk
from tkinter import ttk, messagebox
import sv_ttk  # pip install sv-ttk
from threading import Thread

Explanation:

os & json → To save and load usernames from a file.

random & string → For generating random usernames.

tkinter → The main GUI toolkit.

sv_ttk → A modern light/dark theme for Tkinter.

Thread → To run username generation without freezing the GUI.

2️⃣ Helper Functions

We’ll create functions to load, save, and generate usernames.

CONFIG_FILE = "usernames_data.json"

def load_usernames():
    """Load saved usernames from a JSON file."""
    if os.path.exists(CONFIG_FILE):
        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
            return json.load(f)
    return []

def save_usernames(usernames_data):
    """Save usernames to a JSON file."""
    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
        json.dump(usernames_data, f, ensure_ascii=False, indent=4)

Explanation:

load_usernames → Reads usernames from a JSON file if it exists.

save_usernames → Writes the current list of usernames to a JSON file.

3️⃣ Generating Random Usernames

We can create usernames in different styles:

def generate_username(length=8, style="Normal"):
    """Generate username based on selected style."""
    if style == "Normal":
        chars = string.ascii_letters + string.digits
    elif style == "Lowercase":
        chars = string.ascii_lowercase + string.digits
    elif style == "Uppercase":
        chars = string.ascii_uppercase + string.digits
    elif style == "NumberEnd":
        name = ''.join(random.choice(string.ascii_letters) for _ in range(length-1))
        return name + random.choice(string.digits)
    else:
        chars = string.ascii_letters + string.digits

    return ''.join(random.choice(chars) for _ in range(length))

Explanation:

Normal → Letters + numbers.

Lowercase → Only lowercase letters + numbers.

Uppercase → Only uppercase letters + numbers.

NumberEnd → Ends with a number.

4️⃣ Setting Up the Main Window

Now we create the main GUI window:

root = tk.Tk()
root.title("🎲 Random Username Generator Pro")
root.geometry("970x600")
sv_ttk.set_theme("light")  # Optional: modern theme

Explanation:

root.title → Sets the window title.

root.geometry → Sets the window size.

sv_ttk.set_theme → Makes the GUI look modern.

5️⃣ Global Variables

We store the data and user selections in global variables:

usernames_data = load_usernames()
filtered_usernames = usernames_data.copy()

current_filter = tk.StringVar(value="")
current_sort = tk.StringVar(value="Alphabetical")
current_style = tk.StringVar(value="Normal")

Explanation:

usernames_data → All usernames.

filtered_usernames → Displayed usernames after filtering.

current_filter → Tracks the filter text.

current_sort → Tracks the selected sorting method.

current_style → Tracks the username style.

6️⃣ Adding Username Functions

We need functions for generate, clear, copy, filter, and sort:

Generate in a thread

def add_username_thread(length, count, style):
    """Generate usernames without freezing GUI."""
    def task():
        global usernames_data
        for _ in range(count):
            usernames_data.append(generate_username(length, style))
        save_usernames(usernames_data)
        apply_filter_sort()
        set_status(f"Generated {count} username(s).")
    Thread(target=task, daemon=True).start()

Explanation:

Runs username generation in a background thread.

Keeps the GUI responsive.

Other functions

def clear_usernames():
    if messagebox.askyesno("Confirm", "Clear all saved usernames?"):
        usernames_data.clear()
        apply_filter_sort()
        save_usernames(usernames_data)
        set_status("All usernames cleared.")

def copy_selected(event=None):
    try:
        value = username_text.get("sel.first", "sel.last")
        root.clipboard_clear()
        root.clipboard_append(value)
        set_status(f"Copied '{value}' to clipboard.")
    except tk.TclError:
        set_status("No selection to copy.")

Explanation:

clear_usernames → Deletes all usernames after confirmation.

copy_selected → Copies highlighted text to clipboard.

Filter & Sort

def apply_filter_sort(*args):
    global filtered_usernames
    filter_text = current_filter.get().lower()
    filtered_usernames = [u for u in usernames_data if filter_text in u.lower()] if filter_text else usernames_data.copy()

    # Sorting options
    if current_sort.get() == "Alphabetical":
        filtered_usernames.sort()
    elif current_sort.get() == "Length (Short → Long)":
        filtered_usernames.sort(key=len)
    elif current_sort.get() == "Length (Long → Short)":
        filtered_usernames.sort(key=len, reverse=True)

    update_username_text(filter_text)

Explanation:

Filters usernames based on input.

Sorts by alphabetical or length.

7️⃣ Setting Up the GUI Layout

We’ll create the frames, inputs, and buttons:

main_frame = ttk.Frame(root, padding=20)
main_frame.pack(expand=True, fill="both")

ttk.Label(main_frame, text="🎲 Random Username Generator Pro", font=("Segoe UI", 22, "bold")).pack(pady=(0,10))

Input frame

input_frame = ttk.LabelFrame(main_frame, text="Settings", padding=10)
input_frame.pack(fill="x", pady=5)

ttk.Label(input_frame, text="Length:").grid(row=0, column=0)
length_entry = ttk.Entry(input_frame, width=10)
length_entry.grid(row=0, column=1)
length_entry.insert(0, "8")

ttk.Label(input_frame, text="Count:").grid(row=0, column=2)
count_entry = ttk.Entry(input_frame, width=10)
count_entry.grid(row=0, column=3)
count_entry.insert(0, "10")

ttk.Label(input_frame, text="Style:").grid(row=0, column=4)
style_combo = ttk.Combobox(input_frame, state="readonly", textvariable=current_style, width=20)
style_combo['values'] = ["Normal", "Lowercase", "Uppercase", "NumberEnd"]
style_combo.grid(row=0, column=5)

Explanation:

ttk.Frame → Organizes the layout.

ttk.Entry → Input fields for length and count.

ttk.Combobox → Dropdown for username style.

Buttons

ttk.Button(input_frame, text="Generate", command=generate_usernames).grid(row=0, column=6, padx=5)
ttk.Button(input_frame, text="Clear All", command=clear_usernames).grid(row=0, column=7, padx=5)
ttk.Button(input_frame, text="Copy Selected", command=copy_selected).grid(row=0, column=8, padx=5)

Explanation:

Generate → Calls function to create usernames.

Clear All → Deletes all usernames.

Copy Selected → Copies highlighted text.

8️⃣ Display Area with Scrollbar

text_frame = ttk.Frame(main_frame)
text_frame.pack(expand=True, fill="both", pady=10)

username_text = tk.Text(text_frame, font=("Segoe UI", 12), state=tk.DISABLED, wrap="none", height=10)
username_text.pack(side="left", expand=True, fill="both")

scrollbar = ttk.Scrollbar(text_frame, orient="vertical", command=username_text.yview)
scrollbar.pack(side="right", fill="y")
username_text.config(yscrollcommand=scrollbar.set)
username_text.bind("<Control-c>", copy_selected)

Explanation:

tk.Text → Displays usernames.

Scrollbar → Allows scrolling through many usernames.

9️⃣ Status Bar & Total Count

total_var = tk.StringVar(value=f"Total Usernames: {len(filtered_usernames)}")
ttk.Label(main_frame, textvariable=total_var, font=("Segoe UI", 12)).pack()

status_var = tk.StringVar(value="Ready")
ttk.Label(root, textvariable=status_var, anchor="w").pack(side="bottom", fill="x")

Explanation:

Shows total usernames and status messages like “Copied” or “Generated”.

10️⃣ Run the App

Finally, initialize and run the app:

apply_filter_sort()  # Load existing usernames
root.mainloop()      # Start GUI loop

Congratulations! 🎉
You now have a fully functional Random Username Generator in Python with filtering, sorting, and threading support.