# PySimpleGUI 6: a tkinter wrapper back under LGPL3

> PySimpleGUI 6 wraps tkinter, Qt, WxPython and Remi behind one layout-and-event-loop API. Version 6.3 was released on 2026-08-02 under LGPL3, after the commercial era ended.

**PySimpleGUI/PySimpleGUI** — Python GUIs for Humans! Create any GUI simple or complicated in a way that's intuitive.  Launched in 2018. NEW for 2026 - the LGPL3 Version 6.  Transforms tkinter, Qt, WxPython, and Remi into a simple, intuitive, and fun experience for both hobbyists and expert users. 

- Repository: https://github.com/PySimpleGUI/PySimpleGUI
- Website: https://www.PySimpleGUI.com
- Stars: 13,821 · Forks: 1,820
- Language: Python
- License: LGPL-3.0
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/pysimplegui-pysimplegui

## What PySimpleGUI 6 solves, and for whom

tkinter ships with CPython, but its API is class-based and verbose: you instantiate widgets, call geometry managers, and bind callbacks before anything appears. PySimpleGUI replaces that with two ideas. A window is described as a list of lists, where each inner list is a row of elements. The program then sits in a loop calling `window.read()`, which blocks until something happens and returns an event name plus a dictionary of element values. The README describes the project as "a wrapper for tkinter (and other GUI libraries) that transforms the GUI SDK into a simpler, more compact architecture while still providing detailed customization", and adds that no prior GUI programming experience is needed.

The audience is explicit. The repository topics include beginner-friendly, and setup.py lists "simple easy beginner novice student" among its keywords. In practice this means scripts, internal tools, teaching material and small utilities where the window is a means to an end. If you already know Qt or WxPython well, the wrapper removes control you may want back. The same code can target tkinter, Qt, WxPython or Remi, so a program written once can run against a different backend, which is the main reason to accept the abstraction.

## The layout, read loop and element update model

The mechanism is a persistent event loop over a declarative layout. Elements are created with a `key`, and `window[key].update(...)` mutates them while the window is open. Values are read from the dictionary returned by `window.read()`, keyed by those same keys. There is no callback registration and no widget tree to walk.

The README's own example is the clearest statement of the data flow. A Text element, an Input with key '-INPUT-', a second Text with key '-OUTPUT-', and two buttons form the layout. The loop breaks on `sg.WINDOW_CLOSED` or the 'Quit' event, and otherwise writes a greeting into the output element. Everything the user typed arrives through `values['-INPUT-']`.

```python
import PySimpleGUI as sg

layout = [[sg.Text("What's your name?")],
          [sg.Input(key='-INPUT-')],
          [sg.Text(size=(40,1), key='-OUTPUT-')],
          [sg.Button('Ok'), sg.Button('Quit')]]

window = sg.Window('Window Title', layout)
```

That is roughly half the application. The rest is the while loop, the break condition and `window.close()`. The pattern scales to tables, graphs, tabs and system tray icons, but the shape never changes, which is why the documentation can be read in an afternoon. The trade-off is that long-running work inside the loop blocks the interface unless you use the timer and event-writing facilities; the 6.2 release notes mention `Window.start_timer` accepting an "H:M:S" string and a `write_event_value` mechanism on the Graph element.

## Installing PySimpleGUI and running a first window

The README gives several installation routes. The simplest pulls the current release from PyPI. Run this in a terminal, in the same environment where you will run your script, and pip should report a 6.x version:

```bash
python -m pip install PySimpleGUI
```

If you specifically need the pre-6 line, the README pins it. This is the version most older tutorials and Stack Overflow answers were written against, so it is worth knowing the command even if you do not use it:

```bash
python -m pip install PySimpleGUI==4.60.5.1
```

The README also documents installing straight from the repository, which avoids cloning. The `master` in the URL can be swapped for a release number such as `6.1`:

```bash
python -m pip install --upgrade https://github.com/PySimpleGUI/PySimpleGUI/zipball/master
```

Once installed, a first real use is the name-entry window above. Save it as `hello.py`, run `python hello.py`, and you should see a window titled "Window Title" with a text prompt, an input field, and Ok and Quit buttons. Typing a name and pressing Ok writes the greeting into the second text line. Pressing Quit or closing the window exits the loop and the script ends. The README notes that version 6.2 restored an upgrade path built into the package itself, available from the Home Window or from the command line as `psgupgrade`, which shows release notes and installs a newer maintenance release.

## Where PySimpleGUI 6 is the wrong choice

The project is not developed as a community open source project. The README states plainly that "PySimpleGUI has always been developed more like a proprietary product than an open source project. Pull requests aren't accepted." If your organisation expects to fix bugs upstream or shape the API, that expectation will not be met. You can fork under the LGPL3 terms, but you cannot contribute back through the normal route, and a fork carries the full maintenance burden of a GUI abstraction layer.

The version history is also a real consideration. PySimpleGUI was commercialised, PySimpleSoft announced in February 2025 that it would shut down with support continuing through the end of 2025, and the README says that process is complete. Version 6 is the PySimpleGUI 5 codebase released as open source after, in the author's words, "removing licensing and security components". Older tutorials, forum answers and third-party packages may assume the 4.x API or the commercial licensing model, and the README does not document a rollback path between major versions beyond the explicit pip pin.

Finally, the abstraction is the product. Anything that requires direct access to a tkinter widget, a Qt signal, or platform-specific window behaviour means working around the wrapper or dropping to the underlying toolkit. For a complex desktop application with custom rendering, a direct Qt binding is the more honest starting point.

## PySimpleGUI versus writing tkinter directly

The natural comparison is plain tkinter, which is what PySimpleGUI wraps by default. In tkinter you create a root window, instantiate each widget as an object, call `pack` or `grid` on it, and attach command callbacks or bindings. State lives in your own variables, and you decide when to read it. Nothing is hidden.

PySimpleGUI inverts that. The layout is data, not code. Widgets are addressed by string keys rather than by reference, and the program is driven by one blocking read loop rather than by callbacks. The result is fewer lines and a uniform shape across every window, at the cost of an extra layer between you and the toolkit. Debugging a layout problem means understanding both the wrapper and tkinter, and error messages can surface from the layer underneath.

The other axis is portability. Because PySimpleGUI can target tkinter, Qt, WxPython and Remi, the same layout code can move between backends. Plain tkinter cannot. If you only ever intend to ship a tkinter application, the wrapper buys you brevity and consistency; if you need fine control over a specific toolkit, it costs you indirection. The repository's own topics list pyside2, qt, wxpython and remi alongside tkinter, which reflects that multi-backend intent rather than a single-toolkit focus.

## Licence, maintenance and upgrade cost

Version 6 is released under LGPL3. The README says the PySimpleGUI 5 code was published under the LGPL3 licence on GitHub and PyPI after licensing and security components were removed. setup.py carries `license='GNU Lesser General Public License v3 (LGPLv3)'` and the matching PyPI classifier, and the repository root contains LICENSE.txt. For anyone who used the commercial versions, this is a change in obligations as well as in cost: the LGPL3 permits use in larger works under conditions, including requirements around relinking and notice, that differ from a proprietary licence. That is a question for your own legal review, not something the README settles.

Maintenance looks active by the only measure available here. The repository is not archived, and the last push was on 2026-08-30, which is recent. Releases are frequent: 6.1 on 2026-05-31, 6.2 on 2026-06-14, and 6.3 on 2026-08-02. setup.py reports version 6.3.16 and declares `install_requires=[ ]`, so the package pulls in no dependencies of its own, and `python_requires='>=3.6'` with classifiers through Python 3.14. The upgrade cost is therefore low in dependency terms, but the 6.2 notes show a steady stream of behavioural fixes (Multiline echoing, Calendar field clearing, Graph event loops), so pinning a known-good version and reading release notes before moving is reasonable. The README is candid that the long-term outlook is uncertain.

## Conclusion

Adopt PySimpleGUI 6 if you want a small Python desktop tool and do not want to learn tkinter's widget classes first. Do not adopt it if you need to send patches upstream (pull requests are not accepted) or if your application cannot ship LGPL3 code. Before committing, verify on your own Python version that `python -m pip install PySimpleGUI` resolves to 6.x rather than the 4.60.5.1 line, and read the licence text in LICENSE.txt rather than relying on the PyPI classifier alone.

## FAQ

### What happened to PySimpleGUI?

It was commercialised, and PySimpleSoft announced in February 2025 that it would shut down with support continuing through the end of 2025. That process is now complete, and the PySimpleGUI 5 code was released as open source under LGPL3 as version 6.

### What is PySimpleGUI?

It is a wrapper for tkinter and other GUI libraries that turns the GUI SDK into a simpler, more compact architecture while still allowing detailed customization. The README states that no prior GUI programming experience is needed.

### How do I install PySimpleGUI?

The README's first route is `python -m pip install PySimpleGUI` for the latest version. It also documents installing directly from the GitHub repository zipball, or cloning the repo and running `python -m pip install .`.

### Is PySimpleGUI free?

Version 6 is available under the LGPL3 licence on GitHub and PyPI, after the licensing and security components were removed from the PySimpleGUI 5 code. Older versions and the commercial era had different terms.

### Can I provide examples of how to use PySimpleGUI?

The README's example builds a layout of Text, Input and Button elements, creates a window with `sg.Window`, then loops on `window.read()` until the close or Quit event. It updates the output element with `window['-OUTPUT-'].update(...)`.

### How do I install PySimpleGUI 4.60.5.1?

The README gives the pinned command `python -m pip install PySimpleGUI==4.60.5.1` for the older version. It is listed separately from the current version install.

## Sources

- [License: LGPL-3.0](https://github.com/PySimpleGUI/PySimpleGUI/blob/master/LICENSE)
- [Project website](https://www.PySimpleGUI.com)
- [PySimpleGUI/PySimpleGUI on GitHub](https://github.com/PySimpleGUI/PySimpleGUI)
- [README](https://github.com/PySimpleGUI/PySimpleGUI/blob/master/README.md)
- [Releases](https://github.com/PySimpleGUI/PySimpleGUI/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/pysimplegui-pysimplegui