5 open source Python GUI frameworks

Does your Python program need a graphical user interface? Here are five tools to help you build one.
1 reader likes this.

PixelAnarchy on Pixabay, CC0.

This article was originally published in May 2016 and has been updated with new information.

There comes a time in the journey of most any programmer when they are ready to branch out past the basic examples and start to build a graphical interface to their program.

In Python, the steps to get started with GUI programming are not terribly complex, but they do require the user to begin making some choices. By its nature as a general purpose programming language with interpreters available across every common operating system, Python has to be fairly agnostic as to the choices it presents for creating graphical user interfaces.

Fortunately, there are many options available for programmers looking to create an easy way for users to interact with their programs. Bindings exist for several UI frameworks on a variety of platforms, including those native to Linux, Windows, and Mac, and many that work across all three.



Before going any further, be your own devil's advocate for a moment and ask: Does it really make sense for your application to have a traditional graphical user interface at all? For some programs, the answer is obvious. If your application is inherently graphical, and is either optimized for or just makes sense to be run locally on a single local machine, then yes, you probably should consider building a desktop GUI. Many times, this is made obvious by what you're designing.

But for general purpose programs, don't count out either the command line or a web interface. The command line offers many advantages—speed, remote access, reusability, scriptability, and control—which may be more important for your application's users than a graphical interface, and there are many libraries like ClickCement, and Cliff that make it easier to design great command line programs.

Similarly, a web interface, even for a program meant to be run locally, might be an option worth considering, particularly if you think your users may wish to host your application remotely, and projects like DjangoFlask, or Pyramid all make this straightforward. You can even use a library like pywebview to put a thin wrapper around a web application in a native GUI window.

Alternately, you can use a framework like Pyforms to build a consistent experience across the web, command line, and desktop, all with a single code base.

Still sure you want to build a GUI? Great, here are a few fantastic open source libraries to get you started.

PyQt, PySide, and Qt for Python

PyQt implements the popular Qt library, and so if you are familiar with Qt development in another language, perhaps from developing native applications for KDE or another Qt-based desktop environment, you may already be familiar with Qt. This opens up the possibility of developing applications in Python which have a familiar look and feel across many platforms, while taking advantage of the tools and knowledge of the large Qt community.

Qt is well established in the developer community and has tooling reflecting that. Writing Python applications around Qt means you have access to QtCreator, which features a designer mode to generate code for the layout of your application.

PyQt is dual licensed under both a commercial and GPL license, not unlike Qt project itself, and the primary company supporting PyQt offers a license FAQ to help understand what this means for your application.

For another option to use Qt libraries with Python, consider Qt for Python (commonly known as PySide2), available under the LPGL.


If there were a single package which might be called the "standard" GUI toolkit for Python, it would be Tkinter. Tkinter is a wrapper around Tcl/Tk, a popular graphical interface and language pairing first popularized in the early 90s. The advantage of choosing Tkinter is the vast number of resources, including books and code samples, as well as a large community of users who may be able to help you out if you have questions. Simple examples are easy to get started with and fairly human-readable.

Tkinter is available under the Python license, on top of the BSD license of Tcl/Tk.


WxPython brings the wxWidgets cross-platform GUI library from its native C++ to Python. WxPython looks a little more native than Tkinter across different operating systems because it uses the host system's widgets to construct a GUI. It's fairly easy to get started with as well, and has a growing developer community. You may need to bundle wxPython with your applications, or else require the user to install it on their own, as it is not automatically installed with Python.

WxPython uses the wxWindows Library License of its parent project, which is OSI approved.

Python GTK+ 3

Formerly known as PyGTK, the Python GTK+ 3 project provides Python bindings to GTK objects (windows, widgets, and so on). GTK+ is most famously used as the foundation for the GNOME desktop, but it's available for stand-alone applications on Linux, Windows, and Mac. With Python GTK+ 3, the same framework is available for your Python projects.

When you use Python GTK+ 3, you can use many of the same development tools created for GTK+ itself. Most notably, this includes Glade, an interface designer for GTK+ applications. Interfaces designed in Glade are saved as XML and used by the GtkBuilder object in your application code, but the interface you use is drag-and-drop, making it easy to create a dynamic and responsive UI without having to translate what you see in your mind into layout code.


Built with rapid development and modern devices in mind, Kivy is a toolkit for Linux (including the Raspberry Pi), Windows, Mac, and Android. The project is focused on "innovative user interfaces", and it's been used for multimedia applications, like music controller apps for phones to whiteboarding applications that take up the entire wall of a meeting room.

Kivy doesn't have a visual layout program like QtCreator and Glade, but it uses its own design language to help you associate UI layout with code objects. This makes it easy for you to compartmentalise (both mentally and in the layout code) the classes and functions in your application. Kivy also hosts the Kivy Garden, a repository of user-created widgets and add-ons, so if you're thinking of creating something that Kivy itself doesn't provide, you may it already exists in the Garden.

These are not the only choices you have available to you, not even by a long shot. For more options, check out the "GUI programming in Python" page on the official Python Software Foundation wiki, which lists dozens of other tools. Solutions are available to bind Python to many different widget libraries and GUI tools such as FLTKFOX, and many others. While beginners should probably avoid projects providing only partial implementations, or those no longer actively maintained, there are plenty of good tools for a variety of situations.

Many of the options out there are for traditional applications that take on the windowed look and feel of their parent desktop environment, but there are also times when you may wish to do something completely different, for example, within a video game. There are great libraries for these situations too, like pygamepyglet, and Panda3d.

Do you have a favorite not mentioned here? Let us know in the comments below!

Are you interested in reading more articles like this? Sign up for our weekly email newsletter.

Jason Baker
Former Red Hatter. Now a consultant and aspiring entrepreneur. Map nerd, maker, and enthusiastic installer of open source desktop and self-hosted software.
Seth Kenlon
Seth Kenlon is a UNIX geek, free culture advocate, independent multimedia artist, and D&D nerd. He has worked in the film and computing industry, often at the same time.


Tkinter is very well documented as you mentioned, but rather limited, as Tk is, so it's fine for very simple interfaces but not much more. wxPython is much more capable is and is pretty good, but is rather poorly documented, so you just have to find your way with it.

PySide is an LGPL alternative to PyQt. PySide has also recently been adapted by the Qt project and will enjoy first class status as an official Python binding for Qt.

wxWidgets is nice in many ways, but not Python 3 compatible and thus not really a viable alternative for new projects. A Python 3 rewrite under the name of Project Phoenix is underway, but has been so for several years by now without reaching announced production quality.

TkInter is part of the standard lib, but you do not have to look far to see core devs recommending alternatives.

After working with all these alternatives, I would say that PySide is the most interesting way forward at the moment. It will be interesting for the Python community to see how well the Qt project will take care of it.

I like Kivy framework for Python. You can use the same code to run in all environments: Windows, Android, iOS, OS X, Linux, etc.

Kivy is a great framework and is also great on tablet and mobile devices. The one downside is that it's a bit tough for middle school kids. I did some lessons using pygame and Simple Game Code for my son a while back. SGC is simple, as the name states. Also, Pygame isn't intended for GUI applications. The upside is that pygame is simple to use, even for elementary school kids. Leveraging knowledge from Pygame to introduce GUI fundamentals with SGC is useful. The combination might also be good for simple prototypes. More information here: http://pychildren.blogspot.com/search/label/sgc

In reply to by Greg Krakow (not verified)

This is a really good collection of python GUI options. I really appreciate the cli list too as an alt to GUIs.

You can add this 3 to your list too!

Kivy - One of the more interesting projects, the liberal MIT-licensed Kivy is based on OpenGL ES 2 and includes native multi-touch for each platform and Android/iOS. It’s an event-driven framework based around a main loop, and is thus very suitable for game development.

Pyforms - At just two years old (making it one of the more recent frameworks), Pyforms is a Python 2.7/3.x cross-environment framework for developing GUI applications. It is modular and encourages code reusability with minimal effort.

libavg - This is another third-party library, written in C++ and scripted from Python, with properties of display elements as Python variables, a full-featured event handling system, timers (setTimeout, setInterval), support for logging and more. Like Kivy, libavg uses OpenGL and makes use of hardware acceleration.

What about custom graphic gui? with all the framework you can build standard gui with standard elements, e.g. button, radiobutton, and so on, but what about if i want to build interface with custom graphics as, for example, the kodi interface, or the firefox interface, or every other software that have a gui without the "standard" elements?

What about custom graphic gui? with all the framework you can build standard gui with standard elements, e.g. button, radiobutton, and so on, but what about if i want to build interface with custom graphics as, for example,

I wonder why PyGObject is just mentioned and not even described. Absolutely not complaining about your choices. Just wondering why. Any particular reason? It has a good set of tutorials and documentation. It supports Linux, Windows and macOS and works with Python 2.7+ as well as Python 3.4+.

Among the above-mentioned tools, Tkinter is the easiest tool to develop GUI based interfaces.

curses python bindings provide very flexible console control

PySimpleGUI is a new one that's great for beginners and intermediate GUIs. Runs on Python3 on Windows, Mac, Linux, pypy, Raspberry Pi. Anywhere tkinter runs PySimpleGUI should run.

It's a wrapper around tkinter that presents the programmer with a very Python-like interface. GUIs are simple lists of GUI Widgets. Results from a GUI is a list of return values.

pip install PySimpleGUI

I don't have much experience with GUI frameworks
but I wondering what is the purpose/advantage using non-web GUI - ?
web-GUI provides cross platform solution and doesn't require additional installation/dependencys

IUP (Portable User Interface) is a mature easy to use cross platform native UI desktop GUI library. (Dynamic / Static)

A good list to try. Tkinter is most popular I guess?

I am looking forward to learn GUI programming with Python

Interesting article

This is a really nice summary of the desktop Python GUI tools. For web GUIs, there are a lot of great open-source options for **running python in the web browser** (that's right, no more JavaScript!!!)

Here's an article (and talk video) where I cover 6 different options, with demos:


Well, You should have a look at new tools and tricks all these are old, like Electron there are binding of the electron with Python.
Slack, skype all build with the electron ,
One other trick is to use Flask , I know its a web framework but its really light and can compile into cross-platform apps.

Electron python bindings is definitely worth mentioning, thanks. I may revise this article to include it.

I do disagree with you about the tools mentioned here, however. While many of these are "old" (for some definition of "old"), they're also *current*. Python itself is old, but that hardly keeps it from being an effective solution.

In reply to by Zeeshan ahmad (not verified)

Creative Commons LicenseThis work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License.