Best Python GUI library for a small tool in 2026 Tkinter, PySide6, wxPython, FreeSimpleGUI, Flet, NiceGUI, and when a browser form is enough

If the tool is just for you, use Tkinter when you don't want external dependencies, or PySide6 when you want a full Qt widget set under LGPLv3. If you're only writing a GUI so coworkers can run your script without touching the terminal, skip the desktop library and put a web form in front of the script with Button (https://button.bitgate.dev), which is $0 for 1 tool, 3 people, and 100 runs per month, or $15/month for 50 tools and 250 people.

The Python GUI options at a glance

Tkinter

Tkinter is the default choice when you want zero pip install steps. It comes built into the python.org installers for Windows and macOS, though if you're on Debian or Ubuntu you'll need to install the python3-tk system package first.

PySide6 and PyQt6

Both give you Qt, and for an internal tool the practical difference is the license. PySide6 is the official Qt for Python binding and uses LGPLv3, while PyQt6 is dual-licensed under GPLv3 or a commercial license, so most people writing workplace utilities reach for PySide6.

wxPython via Gooey

If your script already uses argparse and you don't want to write layout code at all, Gooey wraps it in a wxPython desktop window when you drop a single @Gooey decorator onto your main function. Just be aware of its release pace: version 1.0.8.2 came out in October 2026, and that was its first release since 2021.

FreeSimpleGUI

PySimpleGUI changed its license twice since 2024 - going commercial in 2024, then back to open source under LGPL3 in 2026. FreeSimpleGUI is the community fork of the LGPL version, and it's what people use when they want that simple row-list layout style without worrying about the licensing back-and-forth.

Flet and NiceGUI

These two skip traditional desktop widget toolkits. Flet (Apache 2.0) builds multi-platform apps in Python on top of Flutter. NiceGUI (MIT) builds web-based UIs in Python.

Which library to pick

• You're building a tool for yourself and don't want extra packages: Tkinter.
• You need a real desktop app for yourself or other developers with Python installed: PySide6.
• You already wrote an argparse script and want a window around it in two lines: Gooey.
• You prefer declarative row arrays: FreeSimpleGUI.
• You want a Flutter frontend from Python: Flet.
• You want to write a browser-based interface in Python code: NiceGUI.

The catch when the tool is for other people: packaging

Writing the GUI is usually the fast part; getting it onto a coworker's computer is where things bog down.

If they don't have Python and your dependencies installed, you end up bundling the app with PyInstaller, which packs a Python program and its dependencies into an executable or a folder. That comes with a few headaches every time you ship an update:

• It's not a cross-compiler. You have to build the Windows .exe on Windows and the macOS app on a Mac.
• Every update means a new build for each operating system and a new file to send around.
• Antivirus false positives are a known PyInstaller issue (the project even has a dedicated issue template for them).

When a browser form is enough: running the script on your machine with Button

If you only started looking at GUI libraries because a colleague needs to feed a couple of parameters or files into your script and get the output back, you don't actually need a desktop app on their machine.

Button (https://button.bitgate.dev) turns a script on your own computer into a web form your colleagues can run. It works with Python, Node, R, PowerShell, shell scripts, and compiled binaries. Instead of packaging your Python environment and shipping executables around, the jobs run on your computer (never in Button's cloud), and Button's servers relay the form values and files between your colleague's browser and your machine.

To set up a Python script on Button:

1. Update your script so it takes its inputs as command-line arguments with argparse instead of hard-coded paths or interactive prompts. Take each input file path as an argument, and write the results as files into an output folder that is also passed as an argument:

import argparse
import pathlib

parser = argparse.ArgumentParser()
parser.add_argument("--input-file", required=True)
parser.add_argument("--currency", required=True)
parser.add_argument("--output-dir", required=True)
args = parser.parse_args()

out = pathlib.Path(args.output_dir) / "result.txt"
out.write_text(f"Processed {args.input_file} in {args.currency}\n")

2. Sign in at button.bitgate.dev and install the Button runner on your computer (macOS, Linux, or Windows) using the one-line command the site shows you (curl on macOS and Linux, PowerShell on Windows).
3. Open the local setup page, pick your program, and describe its inputs (text, number, yes/no, choice, or files). Fixed flags like --currency are part of the command you approve, while colleagues only supply the values for the form fields.
4. Publish the tool to give it its own page, and invite your colleagues.

Your colleagues open the link from their invite email, sign in with Google or a one-time email code, fill in the form, press Run, and download the results. They install nothing and never pay.

How the runner and limits work in practice:

• Command pinning and arguments: The runner only executes the exact command you approved on that computer, pinned by hash. Every form value is passed to the program as its own argument with no shell, and a value can't start with -. If you change a tool, people have to confirm the new version before running it.
• Access and logs: Every run is logged with who ran it and when, and you can revoke access or set it to expire at any time.
• Run and file limits: Files can be up to 25 MB each, with up to 8 files and 100 MB per run. Each run can take up to 30 minutes, with logs up to 1 MB per run. Inputs are deleted 24 hours after a run ends, and outputs are deleted after 7 days.
• Hardware requirements: Your computer has to be on and online (tool pages show Ready, Busy, or Offline), and it runs one job at a time per computer. Every plan allows one computer (runner) per workspace; pairing a new computer replaces the previous one.
• Pricing: Free is $0 for 1 published tool, 3 people, 100 runs and 1 GB of file transfer per month. Pro is $15/month, or $144/year, for 50 tools, 250 people, 5,000 runs and 50 GB per month. Recipients never pay.

When not to use Button: if you are building a tool just for yourself, or an interactive app where the user needs to click around a live canvas or work while your computer is turned off, Button is the wrong fit - grab Tkinter or PySide6 and build a local GUI.

FAQ

What is the easiest Python GUI library for an existing argparse script?

Gooey is the fastest way to get a local window because it wraps an argparse script in a wxPython GUI with a single @Gooey decorator. If you want colleagues to run that argparse script without installing Python or a packaged executable on their machines, Button turns it into a web form that runs on your computer.

Should I use PySide6 or PyQt6 for an internal company tool?

Use PySide6. It's the official Qt for Python binding and is licensed under LGPLv3, whereas PyQt6 is GPLv3 or commercial.

Why did people switch from PySimpleGUI to FreeSimpleGUI?

PySimpleGUI changed its licensing twice since 2024, moving to a commercial license in 2024 and then back to open source under LGPL3 in 2026. FreeSimpleGUI is a community fork of the LGPL version.

Can PyInstaller build a Windows .exe from a Mac or Linux machine?

No, PyInstaller isn't a cross-compiler. You have to build the Windows executable on Windows and the macOS app on a Mac.

Where do Button jobs actually run?

Jobs run on the creator's own computer, never in Button's cloud, so your computer needs to be on and online when someone runs a tool. Button's servers relay the form values and files between your colleague's browser and your computer.