Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Announcements #142

MikeTheWatchGuy opened this issue Sep 6, 2018 · 1,219 comments

Announcements #142

MikeTheWatchGuy opened this issue Sep 6, 2018 · 1,219 comments
All Ports All Ports announcements Announcements


Copy link

MikeTheWatchGuy commented Sep 6, 2018

Announcements - New Features, Design Patterns, and Methods

I'm unsure how GitHub sends out updates. I don't think people are informed about Wiki changes for example. I've been announcing new features and more importantly, new ways of doing things, on the Wiki. I'm going to put announcements here so they are more visible. If there are objections about the traffic, well, what can I say, it's a busy/active project.

@MikeTheWatchGuy MikeTheWatchGuy added the announcements Announcements label Sep 6, 2018
Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 6, 2018

New use pattern - Element lookup using Keys

keys can be used to lookup Elements. As a result, all Elements are capable of having a key, including non-output elements such as a Text Element.

To get an element object from a form, you call

This is the new, preferred method for doing Updates on elements.

Previously if you wanted to output something to a Text Element, you needed to create the text element outside of the form layout and keep that text element variable around so you can call text_element. Update('new text')

The new design pattern is thus:
In your form layout, include a key on your Element:

layout = [[sg.Text('My text', key='text')]]

Later in your code you can update this Text Element by making this call, assuming the variable form is your FlexForm object:

form.FindElement('text').Update('new text')

The Demo programs have all been updated to use this new technique. This capability and its impact on the length of programs led to pushing version 2.30 out the door quickly.

Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 6, 2018

Borderless Windows are Here

Try them on your next form.
Add this to your FlexForm call:
no_titlebar = True

You can expect to see some of these in the Demo programs.

borderless grayed buttons

You can click anywhere on the window and drag to move it. Don't forget to put an exit key on these windows.

Be sure and make an "exit" button or you'll be running task manager to close your windows. The reason is the when you turn on this option, you will not see an icon on your taskbar for the window. This happens on both Windows and Linux. Thus, if you do not supply an exit button, the user will have no means to close the window.

Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 7, 2018

Grab Anywhere

Tonight's change is perhaps going to be a really cool thing or one that is going to piss people off.

But, hey, I like it this way. If you don't, setgrab_anywhere = Falsein your call to FlexForm.

As the name implies, you can grab and drag your window using any point on the window, not just the title bar. I was only enabling this when the title bar was turned off. I think it's a much superior way to interact with a window.

FlexForm is becoming quite the call!
def __init__(self, title, default_element_size=DEFAULT_ELEMENT_SIZE, default_button_element_size = (None, None), auto_size_text=None, auto_size_buttons=None, scale=(None, None), location=(None, None), button_color=None, font=None, progress_bar_color=(None, None), background_color=None, is_tabbed_form=False, border_depth=None, auto_close=False, auto_close_duration=DEFAULT_AUTOCLOSE_TIME, icon=DEFAULT_WINDOW_ICON, return_keyboard_events=False, use_default_focus=True, text_justification=None, no_titlebar=False, grab_anywhere=True):

So, enjoy a lazy way of interacting with windows on me.

You will want to turn if off for forms with a SLIDER. you need the slider to move, not the window. I'll update the Demos that use sliders to turn off the grab_anywhere.

Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 7, 2018


This one has been requested a number of times. Rather than make a Table Element, decided to see if the current PySimpleGUI is capable of making nice tables using standard Elements. The answer seems to be yes, it's possible with existing Elements. The key was to enable text justification in the InputText element. By right justifying the text in those Elements, it's possible to create a nice looking table.

Here's an example using a ComboBox and Input Elements.

light table

You'll find the code that generated the table in the file It requires the latest PySimpleGUI from GitHub in order to use the justification setting.

This is a "live keyboard" demo. It updates the table values as you are typing.

There are 3 fields at the top of the table. If you enter a value into the 3rd field, the cell that the other 2 cells represents will be changed to that value. Enter 1, 2, 1234 and cell (1,2) will be changed to 1234.

There is a new trick demonstrated in this demo that shows off the power of Python. Rather than pass in a string as the key to the Input Elements, I passed a tuple. Nothing about the key requires it to be a string. The only requirement is that you use the same type to look up the element when you call FindElement or use the key to read the return values.

This is the code that makes the Input Elements:

    for i in range(20):
        inputs = [sg.In('{}{}'.format(i,j), size=(8, 1), pad=(1, 1), justification='right', key=(i,j), do_not_clear=True) for j in range(10)]

See how the key is set to (i,j). This allow me to easily find the Element that is represented by (i,j) later. What to access the cell at (0,0)? This you would make this call:

Hopefully this is enough capability for the folks that need tables in their forms/window.

Copy link
Collaborator Author

Three Point Oh!

So maybe I kinda screwed up the numbering when the last one became 2.30. I didn't think about it looking like 2.3 also. Doh!

There have been a lot of changes lately so perhaps it's time for a major bump.

It's a clean slate

Copy link
Collaborator Author

keep_on_top = True

What might this setting do in a call to FlexForm? If you guessed create a window that's ways on top you're right.

This one little flag enables cool floating toolbars that stay on top of all of your other windows. I'll admit a large portion of this project is for selfish purposes, that I have a platform to develop tools on top of.

Now I've got this nifty toolbar on the top part of my screen, always ready to launch or do something.

floating launcher

Copy link
Collaborator Author

3.0.2 release today to turn off the grab_anywhere feature for non-blocking forms. tkinter is printing out a warning/error message when the form is closed using a button. Doesn't appear to have any effect on the overall functioning, but it's distressing to see. Better to disable this feature for now.

Plan is to add back an override mechanism should a user want it.

Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 8, 2018


Copy link
Collaborator Author

Floating Toolbar - New demo program

This is an always-on-top, compact floating toolbar. They are super-handy to leave running. Something satisfying about writing code that then gets used often, especially if they make you much more efficient.

Copy link
Collaborator Author

Async Forms

Updated the Readme / primary doc to discuss the use of non-block forms.

As explained in the documentation there are a number of techniques to move away from async forms including using the change_submits = True parameter for elements and return_keyboard_events = True

Copy link
Collaborator Author

Floating Desktop Widgets

I've discovered that in about 30 lines of code you can create a floating desktop widget.


If you click the pause button, it switches to Run.


This "Widget" is always on top of the other windows.

Looking for a way of launching these in a way that have no taskbar icons. If launched from PyCharm it behaves this way. If launched from a Toolbar, the toolbar's window is attached to the timer. Close it and the timer closes.

This demo is the first time I've ever combined a ReadNonBlocking with a Read in the same form. The reason for using it in this program is that while the timer is paused, there' s nothing happening so why have the program running the loop when it can wait for the user to do something like click a button. When the button is clicked we return from the Read call.

Thank you to jfong for sending an interesting version of this program. His ideas have rolled into a into the project code many times.

Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 10, 2018

Menus are done

The last of the big features, Menus, was just released to GitHub. With it comes the ability to get the look and feel of a windows program. I don't know if the architecture will lend itself to being used this way or not, but it did seem like a useful feature to add..


Copy link
Collaborator Author

3.7 Support

Thanks to @mrstephenneal we can now say that PySimpleGUI works on Python 3.7. There was a button issue causing trouble. Looks like it's fixed now so I think 3.7 is now safe to with PSG.

Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 10, 2018

Release 3.01.00

Menus! (and a Listbox.Update bug) are the big features.

Since the Menu code is somewhat isolated, and I want to get some users on it, decided to go ahead and push it all out there in 3.01.00

I didn't mention this in the readme section on menus, but by default (you can't currently turn it off) menus are detachable. If you double-click the dashed line then you get a floating version of that menu. Should make for some pretty interesting user interfaces?

tear off

Copy link
Collaborator Author


There have been enough bug fixes to trigger another PyPI release. People have been doing more and more with the Update method. These fixes were mostly in those methods.

Copy link
Collaborator Author

Update methods updated

Added the ability to enable / disable all input elements.
Set parameter disable=True to disable, disable=False to enable, disable=None to leave it alone

A number of Demo programs also refreshed.

Expect a PyPI release soon.

Note that some Update method changes also changed parameter names from new_value to value, new_values to values. Some were different than others. Removed new_ so they all match now. Sorry to those living on the bleeding edge!

Here's a before/after. Elements towards the bottom of the window were disabled.

Yes, even buttons can be disabled now. No more needing to gray out your own buttons!


Copy link
Collaborator Author


Big change this time around is the ability to disable widgets. All input widgets have an Update method that has the parameter disabled that you set to True if you want to disable it.

A few critical bugs in there too which pushed up the release to today.

Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 12, 2018

Resizable Windows, Font settings for input text elements, beginnings of Treeview Element

You can stretch windows bigger now and some of the elements will resize with the window. **

The Input Text Elements did not have a functioning Font setting. Doh! Don't know how that got missed.

The very beginnings of the Treeview element are in there.

Hopefully nothing was broke. Any time I make changes to the core widget packing I get nervous!

** Had to turn off some of the Resizable windows features....Buttons and other elements were moving / expanding in forms that I didn't want the to expand. The change fucked up too many elements to leave on for now.

Copy link
Collaborator Author

Two new Demo programs - CPU Desktop Widget, Spinner Compound Element

Added another Desktop Widget to the demos. This one shows the CPU utilization.

cpu widget

The spinner allows you to change how often it's refreshed

The Spinner Compound Element was done in response from a user wanting to see a different kind of spinner. This one has larger buttons and is laid out horizontally.

spinner compound

The point of this demo is that it's possible to put together multiple Elements into a higher level element. There aren't many of these I can think of at the moment, but given how many user questions are asked, something else is bound to be asked for.

Copy link
Collaborator Author

Table Element, Complete rework of Popups, Death of MsgBox

You can blame the Popup changes on this issue:

All of the Popups were rewritten to use a long list of customization parameters. The base Popup function remained more or less the same.

Decided while I was going all the Popup work that it's time to completely remove MsgBox. Sorry all you early adopters. You'll need to do a bulk rename and then you'll be fine.

Table Elements

Finally have something to show in the form of tables. The element name is Table. While the tkinter Treeview widget was used, many of the parameters were not exposed. If they were, the caller could really mess things up. Better to present a nice "Table-friendly'" interface than something specific to tkinter. After all, the plan is to expand PySimpleGUI to use other GUI frameworks.

A Demo program is in the works.

It's possible to add scrollbars to the Table element by simply placing it into a Column element.

There's still work to do and a good number of bugs, but I encourage you to give it a try.

scrolled table

If you do not put the Table Element inside of a Column, then you can still view and scroll the table, it just will not have scrollbars.

There is a problem currently with keyboard input when placed into a Column. The keyboard keys work fine when NOT inside of the Column but stop working when placed inside a Column Element.

This program will read a CSV file and display it in a window.

import csv
import PySimpleGUI as sg

filename = sg.PopupGetFile('filename to open', no_window=True, file_types=(("CSV Files","*.csv"),))
# --- populate table with file contents --- #
data = []
if filename is not None:
    with open(filename, "r") as infile:
        reader = csv.reader(infile)
            data = list(reader)  # read everything else into a list of rows
            sg.PopupError('Error reading file')

sg.SetOptions(element_padding=(0, 0))

col_layout = [[sg.Table(values=data, headings=[x for x in range(len(data[0]))], max_col_width=8,
                        auto_size_columns=False, justification='right', size=(8, len(data)))]]

layout = [[sg.Column(col_layout, size=(1200,600), scrollable=True)],]

form = sg.FlexForm('Table', grab_anywhere=False)
b, v = form.LayoutAndRead(layout)

It's another bit of PySimpleGUI "challenge code"..... The challenge is to do the same operation in another GUI framework in less lines of code. I would enjoy seeing the tkinter code required to create the window that this 20 line PySimpleGUI program creates. Most of the code deals with reading the CSV file 👍

Copy link
Collaborator Author

Linux Virtual Environment

I finally installed VirtualBox and am running Ubuntu Linux. I tried to install the Mint distro, but the display was scrambled when it booted.

I was surprised how close the Linux screen shots look to the Windows.

ping graph linux
toolbar linux
all linux
ping linux

Even Pong worked the first time.

I don't believe that Python has been labelled the "go to language" for doing cross-platform GUI work. I guess I never stopped to think about it. I don't recall seeing this kind of thinking in posts or books I've read on Python. Perhaps it's time for that to change?

Copy link
Collaborator Author


Released a new release to PyPI. Sorry about all these releases, but features continue to pour into the code. I'm finding even the folks that are actively using PySimpleGUI only run the pip installed version rather than the GitHub version. That means if I want runtime on the code, I'm only going to get any is to do a full release.

There were a number of changes that could f-up, so be on the lookout. The biggest addition to 3.2.0 was the Table Element (beta quality at the moment).

If you are running older programs then you may crash due to missing functions, MsgBox and several others. This is because I've moved 100% to Popup calls. It's not like I haven't been warning people so I don't expect complaints.

Some people are calling ReadNonBlocking prior to your Event Loop so that the form gets fully made. This call is needed if you want to perform actions on elements prior to calling Read. For example, if you want your form to be shown with some Elements set in the disabled state (using calls to Update), you will need to make an additional call after your Layout call.

Instead of calling ReadNonBlocking in these situations, you can call Finalize/PreRead/PrepareForUpdate. I have not been able to standardize on a name, so I'm providing multiple. I'm sure a winner will emerge. I've been using Finalize.

The call sequence becomes this:

while True:
     b, v = form.Read()

You'll also find the Finalize call used in the scripts that use the Canvas Element.

See the Readme for more info on what's in the release. Note that the readme has not yet been updated with the Table Element and several other changes. There's only so much I can do.

Copy link
Collaborator Author

One Line Progress Meters

PySimpleGUI has always had a one-line progress meter called EasyProgressMeter. However, that function has a limitation of only 1 meter being active at a time.

The new way to do Progress Meters is the function OneLineProgesssMeter.

All of the documentation and examples will reflect this new function.

Have to say it's nice to be able to run as many meters as desired without having to worry about more than 1 being on the screen at a time.

I intend to remove EasyProgressMeter within the next 5 or 6 releases to PyPI. I tried to insert a warning in the code, but too much code was shared to fit the message in.

I'm sorry about the change, but really would like to both add this function and rename the capability to something very descriptive. If there is enough revolt over removing EasyProgressMeter, I'll leave it in and simply drop it from all the documentation.


Copy link
Collaborator Author


Yea, yea, it seems like only yesterday that version 3.2.0 was released. That's because it WAS only yesterday. I've been busy.

There are 2 changes I wanted out quickly....

  1. The ability to turn off displaying row numbers
  2. The new OneLineProgressMeter function

The Progress Meter feature alone is a great use of PySimpleGUI. A number of users are using it only for this purpose in their programs.

Copy link
Collaborator Author

MikeTheWatchGuy commented Sep 16, 2018


New demo program - graph ping using canvas.
I'm thinking about creating a Graph Element, something that makes it super easy to users tog create graphs, both line and x,y plot. The demo should how to take a canvas element and graph ping times.

There is another ping-graph demo using Matplotlib. This graph only uses tkinter.

Finally, because the pings take a long time, I moved the ping calls outside of the GUI event loop. Calling ping inside event loop was causing the GUI to respond sluggishly. This is because the ping was taking 1 second which means the gui wasn't being refreshed / wasn't responsive during the second. Now the GUI sleeps for 200 ms while the ping is done by a thread.

This is yet another toe in the water with threading. The problems I saw in the past are no longer there, it would appear.

I also checked in the file that you need for this demo. It's a pure python implementation of ping and works pretty well, even if slow.

ping graph

Copy link
Collaborator Author

Progress Meters

Thanks to @JorjMcKie I've learned more about the performance of the EasyProgressMeter and thus probably the OneLineProgressMeter. The more arguments to display the longer it takes.

Was going to document in the Cookbook / Readme that if you have performance concerns, you can call the progress meter less frequently. You don't have to update it 1 count at a time. It could be like this:

for i in range(10000):
    if i % 5 == 0: sg.OneLineProgressMeter('My 1-line progress meter', i+1, 10000, 'single')

This meter is only called every 5 times through the loop. It finished quite a bit quicker than the test updating the meter every single time.

Copy link
Collaborator Author

PySimpleGUI programs as an EXE file!

The biggest thing to hit PySimpleGUI since Colors.... the ability to run programs written for PySimpleGUI as an exe file. ALL credit goes to @JorjMcKie for this.

There is no need to distribute Python with your programs. It's all included in the exe and folder of supporting files.

From what I understand of nuitka, this code is compiled C++ code, not python code. The performance is thus potentially better! It's the best of both worlds.

Working to get the process documented. It's tricky and required a special script. Stay tuned....

Copy link
Collaborator Author

Graph Element

This one is pretty exciting as it does something new on the screen. The Graph Element allows you to easily create a canvas and draw on it using your own coordinate system. You don't need to do conversions from your graph coordinates to the tkinter canvas graph coordinates.

The Demo program for it is a good example. It displays a pint graph. The graph we're creating is a line graph what we would like to to from 0,0 in the bottom left to 100, 500 in the upper right. This will give us 100 data points along the x axis and up to 500 ms on the y axis.

After creating the Graph Element, we can do 3 operations on it:

  1. Draw Line
  2. Draw Point
    3 Erase

The draw line draws a line from 1 point to another. The points are specified using your graph coordinates, not the tkinter canvas coordinates.


I know I have a LOT of documentation to do.

In the meantime, try using Control+P if you're using PyCharm. Press Control+P while you are typing in the parameters and you'll see a popup showing you what the legal parameters are. This feature is almost necessary when using PySimpleGUI because functions have SO many optional parameters.


I hope to see some cool creations using the capability. I'm starting to see more and more projects pop up on GitHub that use PySimpleGUI! Keep those examples coming! And keep the requests for new features coming too. They have made this such a better package because of your help.

Sample code:

This is your layout:

    layout = [  [sg.T('Ping times to', font='Any 18')],
               [sg.Graph((300,300), (0,0), (100,500),background_color='white', key='graph')],

    form = sg.FlexForm('Canvas test', grab_anywhere=True)

To draw a line, call DrawLine:

form.FindElement('graph').DrawLine(from_point, to_point)

Copy link
Collaborator Author

Movable Graph Element

Made the Graph Element "movable". This means the graph can be shifted when it reaches the "End".

Here's a 1,000 data-point ping graph or 16 minutes woth of pining


Copy link
Owner Launched!

A long-time friend of the project, Mike Driscoll, has launched a new Python instructional website, I think there is only 1 of Mike's Python books that I don't own and I like 100% of the ones that I do. Mike's been incredibly supportive over the years and has been personally there for me anytime I've asked for help.

I have no hesitation at all in recommending his site because I know that he's going to do the best he can and has oodles of integrity. I signed up right away. Really hope PySimpleGUI users will go take a look and see if there's a fit. He's been a vocal supporter of PySimpleGUI and posted numerous tutorials over the years and featured PySimpleGUI in the Pillow book he wrote (an excellent book!! It's featured in the Pillow lesson in the PySimpleGUI Udemy course).

Anyway, go check out!

Copy link

Menu, ButtonMenu and MenubarCustom - "active" highlighting completed

These elements did not quite have the theme applied fully. The version checked into GitHub adds the highlighting color to these 3 elements.

The "active" item is the one under the mouse. Here is a GIF that shows the difference for the MenubarCustom element. The Menu element's changes were limited to the menu items being highlighted as the OS does not support changing the colors of the menubar itself for the OS-provided one. On the left is the one prior to the change.


Copy link

Down For Several Days....

Hello everyone... I hope everyone is safe following the storm. I was without power for 48 hours over the weekend. I was fortunate to not have suffered serious property damage, only minor problems and a 48 hour power outage that has caused a rolling set of problems. I'm really sorry for not being present and responsive. Was excited to see some screenshots for example, but hasn't commented. The Udemy coupon also expired which is a priority to get updated ASAP.

Thank you to everyone for being so patient and of course.... of course... a massive thank you is owed to our PySimpleGUI Wizard, Jason.

Thank you for the kind words

While my social media accounts are generally no longer active, I do a search now and again to see how things are going with users. The comments said about the PySimpleGUI project have been really kind and supportive. It's really touching to read that we're viewed as being responsive and are working hard for our users. The PySimpleGUI users have been unbelievable in how positive, grateful, thankful, and encouraging they are.

I've worked with and managed a lot of teams throughout my career. The PySimpleGUI team has been the most positive group of people I've ever worked with. It's not that I worked with negative people in the past, but rather every individual on this team has said so many positive things and acted in positive ways. Every week it's been like this. Maybe this is normal now, but I don't think so. I've been so fortunate to have crossed paths with truly remarkable individuals in this project. Many of them are very young and while I too started coding at a very early age, I lacked the kind of maturity and wisdom these kids demonstrate. It's very inspiring.... very inspiring.

Copy link

Why Your Help is Needed With Other Projects

I think that I've perhaps not done a good job of explaining why your help is needed when bugs are filed with other projects.

The Announcements Issue over the past months has numerous posts about a specific Mac problem or maybe you've been following the Mac problem specifically that showed up with the 12.3 MacOS release.

It's not just your problem & the challenges are numerous

The first thing to understand with any issue filed is that you are likely not the only person impacted by the problem and will be impacted by the solution. This is true for all things PySimpleGUI regardless of where the root cause of a problem may lie.

Challenge 1 - Get users running ASAP

The challenge is to satisfy users immediately impacted as well as those that may be impacted in the future. It's a challenge that can be frustrating for a number of reasons. While individuals have their interests in mind and are eager to get their problems solved, the PySimpleGUI project has this much bigger picture that is always present. It's enjoyable working on complex problems so I don't mind, clearly, or I wouldn't be running this project.

Challenge 2 - Find the Root Cause

Oh what fun this one is


and oh how frustrating.


This is a very important step, particularly if you plan on working on your project long term. If you don't care about tomorrow, and your code runs, this step may be of zero interest to you. Because the first decade of my career was in fault-tolerant, "five nines" systems that had to stay up, it was drilled into me at a very early age to spend the time and significant energy to get to a root cause. I took it seriously and still do. It bugs me to have a bug that I don't know why it's happening.

Challenge 3 - Get a long-term fix in place

Regardless of finding a root cause, a long-term fix needs to get deployed. This is crammed full of variables that need to be accounted for... the install base, numerous operating systems, Python versions spanning 3.4 through 3.11, tkinter or other GUI framework versions past/present/future, etc.

Challenge 4 - Getting help from users that are "operational"

Some people want a fix to their problem and then go on working/living their life.... perhaps we all do. Maybe think of software development in terms of teams. Team Linux, Team Mac, Team Windows. "There's no I in team", as they say, to which I would add... "but there is in Linux!" Sorry... bad humor I'm good at.

I've got some basic rules that are always present in my mind....

  • Impact the install base as little as possible
  • Be backward compatible
  • Work deliberately, not randomly

An Architecture Diagram For Reference

This diagrams shouldn't be too difficult to understand. Your app runs on top of Python with PySimpleGUI being between you and tkinter (although you can go around/through PySimpleGUI to get right at tkinter too... and PySimpleGUI supplies some APIs to OS calls)


Finally Getting to the Point....

With all that background information fresh, I would like to present a specific scenario, one that in fact mirrors the Mac problem that's been challenging.

Your application, running on PySimpleGUI version 4.30.0 (released in Oct 2020) has been running great. You upgraded your Mac and now it doesn't work correctly.

Tkinter + OS Problem

The problem is traced down to the tkinter/Mac level and found to be a legit problem that happens without PySimpleGUI being used.

There are 3 pieces of software your app depends on:

  1. PySimpleGUI
  2. Python/Tkinter
  3. Operating system

In the world of software development, you don't want to change/upgrade unless necessary. It's costly, increases the likelihood of problems, etc. For some companies, it means their QA Department needs to "recertify" a release/component, a potentially very costly process.

Why PySimpleGUI Changes Are NOT The Answer To Other Components' Bugs

If PySimpleGUI "fixes" this problem by working around the lower level issue, that has 2 bad side effects:

  1. The actual bug/problem is not fixed
  2. ALL users that upgrade to that OS/tkinter version must also upgrade to a new PySimpleGUI

These 2 reasons are why help has been requested by the PySimpleGUI Mac users. Help is needed to get the actual problems fixed so that other users, your fellow OS Teammates, aren't impacted.

This has been the danger in delivering workarounds to users. It gets users up and running quicker, but at a potentially large cost, one that requires all other users to upgrade their copy of PySimpleGUI, and the actual bug continues to go unaddressed.

An extreme action would be to not provide any workaround and send users to the project with the bug. I can't imagine doing that, but it's one path that could be taken.

How You Can Help - Speak Up

The help that's needed is for users to tell the group that has the bug in their code that you are impacted. All users of that OS are impacted. I, as a single individual, have ONE voice. It's easy to ignore 1 person saying there's a problem. It's a lot more difficult if there are 10, 20, 50.

I'm not sure of any way of communicating the severity of a problem, that many people are impacted, than by having those individuals chime in, say something, lend their voice.

Where are we?

The current status of this problem is that movement has stopped. Any Mac user that upgrades to 12.3 or later will see windows intermittently.... unless they upgrade to the emergency release of PySimpleGUI that was posted to PyPI with a workaround. It's a very unsatisfying resolution, but it's where we are.

I'm backing off spending so much time and resources on this issue. The workaround isn't ideal, but it seems to make Mac users happy enough so I'm going to consider it done from a PySimpleGUI standpoint.

Ideally, enough pressure would be put on the tkinter team by our Mac users to get some movement on getting a fix, but that's out of my control. I'm not going to remove the workaround to force users to go get help from that team.

Hopefully, this is a general enough description that you'll get an understanding that there are subtleties and complexities to these systems that you may not have considered but now understand better.

Copy link

Your User Screenshots..... Now on

When you post a screenshot in Issue #10 it will automatically be added to the PySimpleGUI documentation under 2 different tabs. One tab has the full text of the posts. The other tab has only the images.

This has been a feature that @Chr0nicT has been diligently working on for a long time, while working on a lot of other PySimpleGUI issues and upcoming features. Every week I'm impressed with the solutions the PySimpleGUI team is coming up with. Jason continues to be the world's best support engineer.... I've seen none better.... And @Chr0nicT has been our multi-tool/multi-language MacGyver.


It's the users of PySimpleGUI that are the super-star application builders and it's important that new users see the possibilities.

The Demo Programs and PySimpleGUI Utilities don't convey the wide range of applications and styles possible. Your application screenshots do communicate those possibilities so keep them coming! I'm impressed by every image I see. Nothing is too simple/easy/minor to share.

We're still working hard....


While fixes and enhancements are being added on GitHub, I know the pace of those is slower than in the past. While I took Friday off, I'm still working every day on this project. The new documentation is looking good and I'm sure everyone's going to like it. The eCookbook is part of the main documentation for example.

And as mentioned in the issue asking about a call reference for the Web port, all 4 ports of PySimpleGUI have an SDK reference in the new docs. This has required adding docstrings to all of the ports and is a time-consuming operation.

Thank You for the Thank You's!

Thank you for all the kind words and encouragement, publicly and privately! They are all seen and I pass them around as well. They have an impact greater than you know. They fuel the project. It's been a difficult year keeping the project alive and afloat. Having your support has meant so much.

All Python developers need your support, not just me, so show love to others too.


Copy link

Exceptions Made Simple PySimpleGUI-Style

You may have already encountered the PySimpleGUI Error Popup. One of the most common errors is a bad key. Here's an example:


I use these error popups in my personal programs as I can immediately edit the file with the problem by clicking the Take me to error button. You can use them too of course. The function to call is popup_error_with_traceback.

The new version of PySimpleGUI on GitHub, version, has a new feature to help you with the details of your exception.
If you include the Exception information as one of the items to display, then the window will contain information about the exception that occurred.

Here's an example that has a test for an exception in the event loop:

import PySimpleGUI as sg

layout = [  [sg.Text('My Window', k='-TEXT-')],
            [sg.Text('Input an int:'), sg.Input(key='-IN-')],
            [sg.Text(size=(12,1), key='-OUT-')],
            [sg.Button('Go'), sg.Button('Exit')]  ]

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

while True:
    event, values =
    print(event, values)
    if event == sg.WIN_CLOSED or event == 'Exit':
    if event == 'Go':
            i = int(values['-IN-'])
        except Exception as e:
            sg.popup_error_with_traceback('Error on int input', 'Something went wrong', e)


The window is shown when there's an error in the conversion to int. The Take me to error button, as you can see in the image, takes me to the line of code with the popup that reported the error. Because I passed in the variable e, which contains the information about the exception, the window also displays the specifics of the error in the format of the filename, line number, and the message associated with the error.

In this example, the exception happened on line 17. The error message associated with that exception says invalid literal for int() with base 10: 'ABC'

Hopefully this will make finding errors in your program a bit easier, and a lot more pleasant when they do occur.


Copy link

Reminder - User Screenshots Gallery Now Open....

A quick reminder/suggestion that you post a screenshot in Issue #10.

It's always been open and available for you to post a screenshot. Now they have much greater visibility because they are also being put into the main PySimpleGUI documentation, with full text and only the images! A LOT of people are looking at these screenshots. They are the best way of showing the world what's possible with PySimpleGUI.

Your creations, big and small, are unique, different than the stuff I make, diverse, and honestly coming from actual users (making them "authentic"), and.... you'll perhaps get a sense of pride in what you've accomplished by sharing them.

The Emergent Complexity Phenomena

In the new docs, I spent a bit of time discussing the impact of seeing your screenshots. From them, it's obvious that something beautiful happens when making the creation of GUIs open to everyone by providing simple-to-assemble windows. Complexity emerges. Knowing this happens and explaining this happens are not the same as showing this happens. '

Seeing is believing


The Demo Programs are, by design, plain, simple, short, and meant to instruct in using PySimpleGUI. As a result, they appear simple. The conclusion/opinion by some programmers that have not used PySimpleGUI is that "PySimpleGUI is only good for simple applications". Your screenshots dispel that myth, quickly and easily.

Thank You for the Motivation

These applications you're developing and sharing truly are motivating. They're inspirational. They're also educational as you do things I've never thought of doing. They're truly mindblowing to see.


Copy link

PySimpleGUI commented Nov 10, 2022



As mentioned in the current documentation, and the upcoming new docs.,. using StackOverflow and Google to seek information about PySimpleGUI is not suggested and has the likely hood of producing results that are lower in quantity, once correct but no longer, or are flat-out wrong.

Google and SO provide you with the most popular answer, not the most correct answer. There is no human being involved in helping you find the best answer.

Worst yet, because I don't have the bandwidth to support both locations, problems reported there never make it to the project. Enhancements the project could benefit from simply won't happen because I don't know they would be helpful.

SO Answers

PySimpleGUI evolves... the answers there do not. When possible, I edit the old answers I see of mine that are incorrect or done a better way now.

I was informed via email of one this week when a comment seemed to have a designed shaming or embarrassing outcome. I think that pretty much sent the message I needed to see... the reminder that I've no business providing support on SO. So, I'll stop, again.

The Issue Form...

My best is all I can do....And it's what I'll keep doing here. Please open an issue if you have a question or problem. We're here to help. There is a GUI form found by typing psgissue from the command line. I've tried to balance getting the information required to perform support with the time required to gather that information.

There's a certain amount of required information. Negotiation back and forth to get that information was inefficient (what's your version? 4.60.4. And OS?) These used to be the conversations had before working on the problem could begin. Contrary to the voice that's perhaps in your head that the form is there to piss you off, it isn't. If you can't take a few moments to fill in the form, then it's assumed your desire for a solid answer is less than that investment.

We're Working Hard

The project may appear to some that it's not as active. It is quite active. I've got more people working with me now than ever before. It's simply not done so you're not seeing it. I'm still as dedicated as ever. As I've said a number of times in the recent posts, this year has been extremely challenging to keep the project afloat. The financial data is there for anyone caring to do the math.

Thank you for the "Thank yous"

When logging and issue, 99% of the user say "thank you" when it's resolved. That alone has an impact, one that's biggest than you likely know.

Please Post Screenshots

Please keep posting screenshots in Issue #10. They're VERY motivating, not to just me and the team, but to the other PySimpleGUI user. They are part of the documentation now and thus quite visible. They demonstrate the universe of possibilities. It's literally impossible for me to make enough examples to communicate how vast this universe is, but you have the ability to help show the many creative solutions you've built.

All you need to do is copy a screenshot and paste it into the issue. There is even a built-in way to do this. You can use the built-in "Window Snapshot" feature to take a screenshot and drag-and-drop it the file into the issue.


I truly love seeing what you're making!

Copy link

Image Zoom Added to Image, Button, ButtonMenu and Tab elements

You can now scale upwards in addition to downwards when using elements that have images associated with them.

subsample has been the only method of affecting change to an image's size to date. With the addition of zoom or image_zoom you can scale upward as well as combine the two to achieve fractional scaling.

A Test Harness

This code shows in the layout how zoom is specified as well as in element's that provide the capability in their update method. I do realize this is an ugly way to communicate these changes so my apologies.

import PySimpleGUI as sg

right_click_menu = ['Unused', ['Right', '!&Click', '&Menu', 'E&xit', 'Properties']]

layout = [  [sg.Text('Zoom Parameter Tests')],
            [sg.Image(sg.EMOJI_BASE64_HAPPY_THUMBS_UP, key='-I1-')],
            [sg.Image(sg.EMOJI_BASE64_HAPPY_THUMBS_UP, subsample=2, key='-I2-')],
            [sg.Image(r'C:\Python\PycharmProjects\PSG\Logos\Logo 372x37250x50.png', zoom=2)],
            [sg.ButtonMenu('',  right_click_menu, image_source=sg.EMOJI_BASE64_FINGERS_CROSSED, key='-BMENU1-', text_color='red', disabled_text_color='green')],
            [sg.ButtonMenu('',  right_click_menu, image_source=sg.EMOJI_BASE64_FINGERS_CROSSED, image_subsample=2, key='-BMENU2-', text_color='red', disabled_text_color='green')],
            [sg.ButtonMenu('',  right_click_menu, image_source=r'C:\Python\PycharmProjects\PSG\Logos\Logo 372x37250x50.png', image_subsample=2, key='-BMENU3-', text_color='red', disabled_text_color='green')],
                           sg.Tab('1/2 size', [[sg.T('1/2 size')]], image_source=sg.EMOJI_BASE64_HAPPY_JOY, image_subsample=2),
                           sg.Tab('2/3 size', [[sg.T('2/3 size')]], image_source=sg.EMOJI_BASE64_HAPPY_JOY, image_subsample=3, image_zoom=2),
                           sg.Tab('Normal size', [[sg.T('Normal size')]], image_source=sg.EMOJI_BASE64_HAPPY_JOY),
                           sg.Tab('2X size', [[sg.T('2x size')]], image_source=sg.EMOJI_BASE64_HAPPY_JOY, image_zoom=2),
            [sg.Button('Go', image_source=sg.EMOJI_BASE64_HEAD_EXPLODE, image_subsample=3, image_zoom=2), sg.Button('Exit')]]

window = sg.Window('Image Zoom Tests', layout)

while True:
    event, values =
    print(event, values)
    if event == sg.WIN_CLOSED or event == 'Exit':
    if event == 'Go':
        window['-I3-'].update(sg.EMOJI_BASE64_HAPPY_THUMBS_UP, zoom=4,)
        window['Go'].update('', image_source=sg.EMOJI_BASE64_HEAD_EXPLODE, image_zoom=2)
        window['-BMENU2-'].update(image_source=sg.EMOJI_BASE64_HEAD_EXPLODE, image_zoom=2)
        window['-BMENU1-'].update(image_source=r'C:\Python\PycharmProjects\PSG\Logos\Logo 372x37250x50.png', image_zoom=2)


This is how the code looks when executed:



Hopefully this will help a few of you with scaling without needing to pull in the Pillow package. While crude, there's at least the ability to go in an upward direction now.

Looking forward to seeing what you make!

Don't forget to share your creations in the screenshots Issues #10.

Copy link

New Demo -

Decided to go with the "more explicit" description in the filename for this demo. Wanted to make sure lots of keywords got hit.

This Demo Program provides code that allows you to a multi-threaded PySimpleGUI program that looks and feels like your threads are calling PySimpleGUI directly.

It wasn't until a question was asked about how to show windows from a thread that I realized no demo program or Cookbook Recipe exists for doing this specific operation. All of the multi-threaded Demo Programs assume you have a window for your application, and that some action you take will then start a thread, etc.

No Window, No Taskbar... Initially....

When you run this design pattern, the result is that nothing is shown on the taskbar or on the screen until your thread indicates it wants to show something. This was the missing use case.

Implementation Syntax

The way this demo is designed to work is that your code, running as a thread, communicates with the main-thread (that is controlling the GUI). The information passed to the main-thread is a lambda function. This allows you to write code that resembles directly calling PySimpleGUI.


This is the function that's part of the demo that communicates with the main-thread. I used the term "Delegate" to indicate that the main-thread is making PySimpleGUI calls on behalf of the thread. The thread is "delegating" the action of making the PySimpleGUI call.

This function takes only 1 parameter, a lambda expression. In this example, a call to popup_scrolled is being made. The call to make_delegate_call returns immediately. The request is placed in a queue that is part of PySimpleGUI itself.

make_delegate_call(lambda: sg.popup('A plain popup call'))


You'll want to be cautious in how you make your calls. It's OK to make a blocking call to a function like popup. Just understand that doing so will cause other requests you have to wait until the blocking call completes.

Entire Windows

You're not limited to making calls like popup using this design. You can create entire windows complete with an event loop. I recommend creating a function that does it all... make the layout, the Window, run the event loop... and then use the make_delegate_call to call that function.

Screenshots Please!

Please keep posting screenshots in Issue #10 . Your screenshots are a popular destination in the documentation.


I hope you all have a safe and enjoyable weekend!


Copy link

The Documentation Search is FIXED!

Our talented documentation wizard, @Snaiel has fixed the problem we've been having with searching the documentation at


He's been quietly working away at the new documentation, which I'm 100% confident will stun everyone. We're working hard to get it complete and rolled out. It's worth the wait... definitely worth it.

NOTE - on Chrome, you may need to reset your cache for the site

Sneak Peek

Here's a little peek at the new documentation and how it's been heavily paginated and uses collapsible table of contents entries. Gone is the monolithic main page... honest....

Here you can see that all 4 of the ports of PySimpleGUI are represented as a call reference. This screenshot is subject to change, so not promising anything will be exactly as shown, but do want to share how exciting and different it all is.


Copy link

Udemy Sale!

I didn't know that the coupon code currently shown in the docs, readme, code, etc, has expired. Udemy doesn't inform me and somehow I missed seeing the entry on my calendar.

For the next 5 days, you can use this coupon to get the course for $9.99

This coupon is good for $13.99 and lasts for the next 30 days.

Udemy has some odd restrictions on how long a coupon can be used and what prices are available. I can't create, for example, a $9.99 coupon that lasts for 30 days. The lowest I can use for a 30 day coupon is $13.99 so that's what I've been using.

If you've been following this project for a while, you'll know that last Christmas, when the course was launched and for several months after, the cost of the course was $100.

The lowest price...

Most of the PySimpleGUI users are not in the USA and many are from areas of the world where income is such that a $100 course isn't affordable. So I decided to drop the price in May.

The number of enrollees hasn't risen to provide the same level of income as the $100 price was bringing in, but I decided to keep the lower price. While Udemy helps with income, it is far from enough to cover the basic costs of the project. It was a solid attempt to create a stable funding situation, but a failed one. $13 or $100... neither has a significant impact on the project.

Holidays are coming...

I hope everyone has a safe and joy-filled holiday season!


Copy link

3 Million Installs....


We've hit a milestone of sorts with PySimpleGUI. Last week the total number of installs, as reported by PyPI, pass the 3 million mark for the tkinter port. This is one of the reports that I run on occasion:


I generally don't draw attention to analytics such as this. It feels like bragging to me, something that I don't feel comfortable doing. I've privately watched and used analytics to help me stay engaged and working hard on the project. It took over 4 years to get to 3 million. At the current rate of installs, another million will be added in under 6 months.

PySimpleGUI is What I Do

As mentioned in the readme, this project and these products, are what I've dedicated myself to doing. It's what I do every day of the week. I believe in PySimpleGUI and have been making the investment to keep building, maintaining, and improving it. Also in the readme is the discussion on funding. Like bragging about the number of installs, asking for financial help is not a particularly pleasant activity. I do it, but infrequently.


2021 (and a chunk of 2020) was the "Year of Udemy". A lot of time and expense went into creating the 61-lesson "Best Seller" course on PySimpleGUI, complete with interactive exercises. I'm grateful to everyone that's taken the course. I'm grateful to everyone that's provided financial and simply kind words. I'm very fortunate to have that help. The impact it's had financially has been underwhelming. It will take some time for the course to pay for the cost of making it. Basic hint - it's under 4 digits per month of income.


2022 has been a "Year of Getting Professional". While not yet released, the upcoming changes are focused on professionalizing PySimpleGUI. Reworking the documentation top to bottom, getting all of the ports to an acceptable level of built-in documentation (docstrings), and adding additional security to help users know when they're running an "official version" of PySimpleGUI code. There are more features that I'll make an announcement about when we're closer to releasing the code.


2023 is going to be the "Make or Break" year. I ultimately need to determine if the project is going to continue. To date, it's nowhere near sustainable. The income doesn't cover the cost of the project, meaning that it's not only unable to allow me to pay for my cost of living, but I continue to rack up debt, borrowing money, to keep the project functional.

This isn't new information if you've followed the over 1,200 announcements I've made since Sept 2018. The data is available should you wish to look at the GitHub Sponsorships and do the simple math required to calculate income from Udemy. It would be great for the project to keep going. I'm hopeful, but more than hope's required to keep the project going.

I'm Sorry for the delays....

I know that the pace has slowed in terms of the features you see being released. I'm doing the best I can with what I've got. I try to be OK with that and hope that everyone else is as well.

Thank you to the PySimpleGUI team and supporters!

@jason990420 is here providing support and ideas for how to keep improving our code. His contributions have been truly unbelievable. We've got over 2,400 closed bugs thanks to Jason.

@Chr0nicT and @Snaiel are delightful to work with and have made enormous contributions to the project (many of them you've not yet seen.... so just wait... it gets even better!)

These aren't the only people helping make this project the success it's been. It's not a solo effort and never has been. I also rely heavily on my friends and they've not let me down when I've asked for help, or I've shown I need help. I took the "surround yourself with people smarter than yourself" advice literally and seriously.

Happy Holiday

It's that season and I hope that everyone has a safe and enjoyable holiday.


Copy link


The ChatGPT release has created a bit of a stir, particularly in generating code. It may be helpful to share this information to stop potential uses and abuses.

My Opinion

My usual disclaimer - computer science is filled with subjective answers.... opinions. I often state my opinion and try to make sure that it's understood when I'm doing this.

"Artificial Intelligence" is such a misleading term. It has the word "Intelligence" in it and as Roger Penrose has said (paraphrasing) "Intelligence cannot be computed". It does have the "Artificial" part right. What AI does is artificial. It's a clever fake and this is the beauty and the danger.

I'll be impressed with AI's programming capabilities when a program creates something like PySimpleGUI or it fixes bugs posted here, like the Apple invisible window problem. Until then, it's another tool, not a miracle.

Stack Overflow's Policy


Shortly after posts of "code generated by ChatGPT" started to be posted, one of the PySimpleGUI team members sent me the StackOverflow policy:

The last line of the policy sums up their overall feeling about someone posting GPT created code:

Moderators are empowered (at their discretion) to issue immediate suspensions of up to 30 days to users who are copying and pasting GPT content onto the site, with or without prior notice or warning.

My Tests

My summary/takeaway...
AI algorithms are skilled at fooling human beings.

One thing I noticed in the "code" it produced is that it used old calling conventions.

window = sg.Window('Reddit submissions').layout(layout)

# Infinite loop that checks for input events
while True:
    # Read the input events
    event, values = window.Read()

These are older constructs that you'll not see in the documentation and demo programs. So right away, you're being led astray and into legacy ways of coding that may not work any longer.

The other thing I noticed, and this I believe is the main argument that StackOverslow was making is that the code "looks legit". It looks like code that should run.... and... well, sometimes it got lucky and did. Other times, it didn't.

Just Say No

Simply put, GPT is not designed to write code and doesn't write code. It guesses at the task and sometimes, like people, it guesses right. The Chatbot itself will tell you that it can't write code if you ask in the right/wrong way.

AI Inside

OK, so I've said some not-so-flattering things about AI, but I do want to acknowledge that it IS a powerful technology. The PySimpleGUI Designer (called Sketch-It) has not yet been released and I hope to release it next year after all these current changes are released. It uses AI algorithms to generate code, but the part that does the code generation is not the part that uses AI algorithms. That part of the code was written by human beings. The design it uses may be possible without AI, but it would be much more difficult.

Like all technologies, anything can be made to sound bigger than it is. Edge cases can be found that make something look really amazing (just look at PySimpleGUI 1.0 if you want an example... it worked great for simple GUIs, but lacked the more complicated elements like Column so it's use was limited).

Stay in School... Be a Programmer

If you're learning to code, your future job is not at risk anytime soon due to AI. Just as millions of Uber Drivers have not been replaced by self-driving cars, as predicted years ago, programmers will not be replaced by AI code in the mid-term-future. I'm doubting it'll happen in my lifetime... but, I'm old, so factor that in. Until then, I'm going to keep having the time of my life writing code and leave the worrying to the youngsters.

Want to beat AI? Study and write code...

image image

It'll keep you busy building things that help people and distracted from the machines taking over (the task of fooling people).

Copy link

🎵 "Christmas Timer Is Here" 🎵


I hope everyone that celebrates Christmas has a very Merry Christmas today. Everyone else Happy [Holiday of your Choice]!

I was feeling nostalgic for Charlie Brown's Christmas and the beautifully written Vince Guaraldi song (that I used to know how to play on the piano but have forgotten) "Christmas Time is Here"

I recently released a Demo Program this past week that created and managed timers. I had some time on my hands the past few days as there was a storm and I lost power for a day. I had the bright idea of pulling this timer functionality into PySimpleGUI itself.

Timer Versus Timeout

Many programs use the timeout parameter of the call to get a "heartbeat" type of design pattern. The way the timeouts on reads are designed, it's not a very reliable way to get a regularly spaced timer event. The reason for this is that will return as soon as it gets an event and it cancels the timeout when an event occurs. It was designed to always give you an event within a certain amount of time.

The new timer feature provides a regularly spaced timer event regardless of other events that happen. The Demo Program posted a couple of days ago provides a regular set of timer events, but it requires a fair amount of code, including the use of threads. You'll find the code to that demo here:

window.timer_start and window.timer_stop

Use the new These are your new window.timer_start methods to start a single timer or a periodic timer. The timer will return an event sg.EVENT_TIMER. You can also specify your own key to use for the event. In the values dictionary (values[event]), you'll find a timer_id that tells you which timer caused the event. This timer_id is returned from timer_start.

If you want to stop a timer, call window.timer_stop with the timer_id.

If you close a Window, then all timers for that Window will automatically be stopped.

Simple Format of Call

The simple format of the start timer call takes 1 parameter, the timer value in milliseconds. To get an event once a second call:


If you only want a single timer event, then you'll set the repeating parameter to False. This call generates a timer event after 10 seconds:

window.timer_start(10_000, repeating=False)

New Demo_Window_Timer

You'll find this code in the new demo program that was just posted along with the changes for this feature. It shows how to both start and stop timers.

import PySimpleGUI as sg

    Demo Program - Window Timers
    Uses the PySimpleGUI Window Timers to generate single or periodic timer events.
    Requires version or greater of PySimpleGUI.
    Copyright 2022 PySimpleGUI

def main():
    layout = [  [sg.Text('Demonatrataion of Window Timers', font='_ 15')],
                [sg.T('Timer duration in ms:'), sg.Input(1000, key='-DURATION-', s=4), sg.Checkbox('Repeats', True, key='-REPEATS-'), sg.Button('Start')],
                [sg.T('Timer ID to stop:'), sg.Input(key='-STOP-', s=4), sg.Button('Stop')],
                [sg.Output(size=(90, 10))],
                [sg.Button('Does nothing'), sg.Button('Exit')]  ]

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

    while True:
        event, values =
        print(event, values)
        if event == sg.WIN_CLOSED or event == 'Exit':
        if event == 'Start':
                duration = int(values['-DURATION-'])
            window.timer_start(duration, repeating=values['-REPEATS-'])
        if event == 'Stop':
                id = int(values['-STOP-'])


if __name__ == '__main__':

Enjoy the Holiday!

If you're getting a break from work, enjoy the time away from the office! It's a season for rest and recovery (and fixing broken water pipes due to the cold weather in my case).

I hope everyone has a safe and happy holiday!

Copy link

PySimpleGUI commented Dec 30, 2022

New Year, New PySimpleGUI Updates Coming...

There has been a tremendous amount of work going on that hasn't been released. I've been talking about the documentation update for many months. There's no doubt that everyone is going to love the new docs.

I thought sharing a screenshot of the new docs would maybe be helpful to show the extent of the rework and rewriting happening.

Not only has the main documentation been extensively reworked and reorganized, but it's highly interactive. The eCookbook is now part of the documentation itself, and as you can see in the sample screenshot, there are interactive Trinkets embedded within the documentation. They're not limited to the eCookbook.

The navigation bar on the left has gone through a complete transformation. Gone is the one long massive table of contents. Instead, there are collapsable sections. There are so many improvements that it would take me pages of describing them so I'll just show you this screenshot and let you see for yourself soon when all this is finally relesaed.


Thanks for the Patience

Thank you all for being incredibly patient while this work is happening. The bug fixes and enhancement implementations have slowed in their pace, but haven't stopped entirely. I try to keep a mix of activities.

It's a Teamwork Project

Jason image has been such a huge piece of the overall PySimpleGUI experience. BTW, if you've not discovered the Easter Egg, then using your IDE's code completion while typing in an EMOJI name, you'll find he's represented in the code as the Wizard he is. He's been the support for PySimpleGUI for a long time and has made it possible for me to concentrate on leading the team and making these new changes that hopefully will propel PySimpleGUI into a whole new phase. I owe a huge HUGE thank you for his contributions and incredible endurance as he is here, helping everyone, every day.

Behind the scenes, another team member (also an easter egg), Tanay image has been the project's Jedi, able to take on anything and everything I've thrown at him.

Thank You for the "Thank You's"

Maybe it's silly, but I really appreciate the kindness and gratitude I see so frequently here. Many of you thank Jason for his help. I get a warm fuzzy feeling reading those. The overall experience has truly been "the dream come true I didn't know I had" and it's because of the users of PySimpleGUI that this dream is happening. Thank you for making it a special experience.

I'm quite hopeful that 2023 will be the year PySimpleGUI will be successful in becoming a thriving project able to continue into the future. With your help, it will be. Thank you for the ride of a lifetime....


Copy link

Why This Topic?

I don't want this place/space to be where I state a bunch of my personal opinions. That's not the point. This is all about PySimpleGUI.

I'm seeing PySimpleGUI used as an example of where it "works". But most importantly, it's the PySimpleGUI project's goals that have me concerned. Fun and user success are the goals. Having generated code leading users down a path that's incorrect may lead to frustration and failure. Both are not fun and not successful.

Chat Fails

Cherry-picking examples of Chat AI solutions for programs has been happening quite a lot I think. It's just as easy to cherry-pick failures. Even though there are warnings that are often shown that were written by the developers of GPT that it is not appropriate for generating code, lots of people are using it for this. That's fine... until it starts to be posted and others don't understand it's a terrible idea.

Here's a cherry-picked failure I got while generating text, something it is designed to do really well.


The Gartner Hype Cycle

I hadn't heard of this until recently. It's interesting for a variety of reasons. One is to explain those "this will change everything" events that don't change everything. The other is for entrepreneurs looking to get funding for a new idea in a "hot space". Hit pitching your idea at that first peak and you may get better funding.


There Are Vaid Uses

These things are tools and powerful ones. But like power tools, they need to be used with care and appropriately.

For PySimpleGUI programs, use the other AI, Actual Intelligence, to learn and produce code.

Copy link

GitHub Version Number Changed To

I apologize for the confusing way I've been managing the PySimpleGUI version number for the version on GitHub. I should have bumped the version number higher or added yet another digit to the version that was released to PyPI.

PyPI has version 4.60.4 at the moment.

By changing the GitHub version to it's more clear that 4.60.4 does not contain the changes that are in the version that's posted to GitHub.

A large number of changes have been accumulating because they are part of a much larger release that's coming as part of the documentation rewrite. All of the PySimpleGUI ports are being upgraded. The other 3 ports have docstrings added, which not only provide documentation while writing code, they are also used to generate an SDK call reference for each port:


New Demo Program

Yesterday a new Demo Program was released that saves and loads Input elements automatically. It uses a dictionary to both set the key and the default value. It enables elements to be defined in a way that utilizes the settings file without cluttering up the layout.

The trick is to use a helper function make_key to create both the key parameter and the default_value parameter


Because PySimpleGUI automatically creates the User Settings JSON file for you based on your file's name, you can directly use the User Settings calls without first explicitly "opening" a settings file.

def make_key(key):
    Returns a dictionary that is used to pass parameters to an Input element.
    Another approach could be to return an Input element. The downside to that approach is
    the lack of parameters and associated docstrings when creating the layout.
    :param key:
    :return: Dict
    return {'default_text':sg.user_settings_get_entry(key, ''), 'key':key}

def main():
    layout = [  [sg.Text('Automatically Load and Save Of Inputs', font='_ 15')],
                [sg.Text('Input 1'), sg.Input(**make_key('-IN1-'))],
                [sg.Text('Input 2'), sg.Input(**make_key('-IN2-'), background_color='green')],
                [sg.Text('Input 3'), sg.Input(**make_key('-IN3-'), text_color='blue')],
                [sg.Text('Input 4'), sg.Input(**make_key('-IN4-'), size=5)],
                [sg.Button('Exit (and save)', key='-EXIT SAVE-'), sg.Button('Exit without save')]  ]

    window = sg.Window('Save / Load Inputs Using User Settings API', layout)

Copy link

PySimpleGUI commented Feb 7, 2023

New Custom Elements Dark Mode Demo Program

Custom Elements Demo

I saw a request from many years ago on another site asking about duplicating a GUI that was supplied. So I gave it a shot for part of it, just to see how much work it would be.

Using to grab parts of the image of the sample window, I saved them to PNG files. I also grabbed the various colors and made a new theme.

Then I used the psgresizer utility to take each of those PNG files, turn them into BASE64 encoded strings which were then pasted into my source file. I didn't do a perfect job of making the assets pixel for pixel the correct size. It's a quick mockup.


It took me maybe 20 minutes to make the entire demo. It's far from perfect and you could say it's a little brute-forced since the event loop handles the logic for each custom element. But even all the logic for the custom elements is only 20 lines long. It's less than 100 lines of code, total, including all of the assets. Everything you see is in the file. With just a little bit of time and patience, a wide range of custom interfaces is possible.

Custom Elements Dark Mode

Copy link

New "Policy" added to the GitHub Issue instructions

My goal is not to "rain on anyone's parade"..


"Fun" and "your success" are important goals of the project. They are the goals of the project. The word "policy" doesn't sound like either of those, but in this case, it fits both of these goals.

Like StackOverflow, I've decided to make an explicit statement regarding ChatGPT-related Issue posts. In short, they're not allowed. The StackOverflow staff have done an excellent job of explaining why this is a good idea, at least for now.

I mean no disrespect nor am I trying to be mean or a jerk by making the statement - If you want someone else to write your code, hire a programmer.

Using a tool in an attempt to have code written for you is no different than hiring a programmer, a human being, for the same task. Either you're making an attempt to learn or you're "outsourcing it". At the moment the AI tools are nowhere near the quality level to produce useful code.

What I see happening or likely to happen:

  • Someone wants some code that does X
  • They type into a chatbot a question asking for code that does X
  • The chatbot provides code
  • The user runs it, sees it doesn't work, and then copies and pastes the output into an Issue and asks for help

This process takes less than 1 minute for a user and is very close to asking for free consulting. "Here's a piece of code that I don't understand, please make it run".

There is no shame in asking for help. That includes asking for a programmer to help write the initial program. It will likely work, AND the programmer can teach you how and why it works.

I've hired programmers from Fiverr. There are some good ones there and they're not expensive.

I'm as excited about this technology. I signed up for the Bing version and was approved for their GPTChat feature recently. My decisions on this have been based on my own personal experience using this technology. If I thought AI's were capable of being a positive addition to the programming process or the educational process, I would of course be very supportive. In my opinion, we're not there yet and all the hype around the chatbots is not helpful, especially for beginners.

So, for now, I've asked that no GPTChat code or generated information be posted. Is this a permanent restriction? I don't plan on it... as soon as the results are "good enough", I'll reassess.

Copy link

ChatGTP Is Not "All Bad"

I would like to counter-balance the "policy" posted above and the warnings for a moment,. as this is clearly useful technology.

While the hype around AI is likely at a deafening roar level in the media (I dunno... not paying attention to the news), and I've made several announcements about not using it to generate code, there is value in using the tools and have a concrete example.

I signed up for Bing's version some time ago and was recently approved. It's a powerful tool and I'll take one of those, thank you! It's a great search engine, but I still urge caution. I'm betting you wouldn't want to only see the first Google search result. The same holds true with these chatbots. They're highly skilled at being wrong with great confidence. There's no magic here. The more you can be mindful that these tools are 100% mathematical probabilities and language patterns with zero "intelligence", the better results you'll achieve by augmenting the answers with additional searches and other tools.

When ChatBots Have Different Opinions...

Prior to Bing's version, I have been using a PySimpleGUI front-end to OpenAI's ChatGPT. I've been hacking/customizing one that you'll find in this awesome user's repo:

I've not researched enough about the implementation to understand how easy or difficult it is to manipulate responses. From this test, I think it's clear that there's a fair amount of control the developers have.

When I asked the original ChatGPT about code-writing abilities:

Can ChatGPT be used to write software?

I receive the same warning I've been seeing from the start:

No, ChatGPT is not designed to write software. It is designed to generate natural language responses to user input.

This response led me to believe that the developers at OpenAI had specifically planted this information.


Bing's version of ChatGPT has a completely different answer:

ChatGPT is a large language model chatbot developed by OpenAI based on GPT-3.5. It can interact in conversational dialogue form and provide responses that can appear surprisingly human. It can also write essays, summarize documents and write software.
However, ChatGPT does not have the ability to search the internet for information and it may not know what’s true or accurate. d It also may not be able to write high-quality code that meets your specific needs or standards.

That answer is, uhm, different than the one I received yesterday, which did not have caution about the quality of the code.


I DO Use This Tool... For me... it's been a great starting point...

I've seen some people say that they find it useful for finding libraries. I've tested this use numerous times and it's worse than hit or miss. PySimpleGUI was missing from lists of Python libraries sometimes. Given the data on the Internet, the websites that list "the best libraries for XXX", this doesn't surprise me. There are decades of these articles out there. Maybe start there for libraries, but I wouldn't trust it too much for anything that you want to be "timely" or "up to date".

If you're working with a specific library, that is mature, then it's a great place to start.

PySimpleGUI is not what I call a "mature library". It's ever-evolving and the techniques programmers used and capabilities PySimpleGUI had in 2018 are very different from those today. tkinter's mature as is much of the Python standard library. Be an intelligent user of the tool.

An Example From Yesterday...

I was working on a problem with Tabs and I use one of the calls to get the "currently active tab". I normally would go to 4 or 5 different tkinter reference sites and look up the calls for the Notebook widget.

One thing I like about Bing is the references it provides so you understand where the data originated and can check the source website if needed or discount the information if it's an old post. In this case, I learned about the notebook.index call. PySimpleGUI uses the call. It was the answer I needed and could go look up more info about the call.


"Give me a hint"

My overall approach to these tools is to not use them in an absolute manner. They don't have THE answer. They've got some answers.... or maybe they don't. The problem I see is that the replies, unlike if you asked a friend, are given with complete confidence. A friend would at least tell you, "I'm no expert, but I've used the library once... maybe look at ....". Or "I don't know". At least a friend doesn't fabricate names of libraries that don't exist, ChatGPT said I wrote several that don't exist... complete fabrications, but stated as fact.

Be careful out there!

And keep building! I'm loving seeing what people are creating.


There are some amazing applications being built! Thank you for sharing them. image

Copy link

Out until Sunday....

I have some personal matters to attend to. I'm taking a rare weekend, somewhat off. I'll be back on Sunday for a bit. The Udemy coupon is expiring so that will get fixed up then. I'll also be out a few days early next week.

New Demos, New Features

There have been new Demo Programs released since the last announcement and a number of new features added to the GitHub release as well. Take a look at the Demo Programs section if you want a sneak peek before I write anything else about them.

Upcoming Releases

The majority of my time is spent on upcoming releases and new documentation that I've been writing about for months. I apologize that it's taking so long and that my time is split between support here and the work you've not yet seen. It makes the project look a bit like it's languishing, but I assure you it is not.

GitHub Dumped PayPal

The Sponsorship situation is particularly bad for open source across the board on GitHub now that PayPal was dropped. This project's sustainability I'll write about in the future but thought it worth mentioning since all open-source projects are struggling financially.

Thank You For The Kind and Supportive Messages

I really appreciate the comments in the GitHub issues. It's been what keeps me working on this project every day. Your gratitude is the fuel for the project.

Back on Sunday....


Copy link

Reminder - My attendance is spotty this week

As I mentioned in the comment above I will be unable to be fully present this week here with the project. Friday is the soonest I'll be back operating at 100%, or thereabouts.

Getting as much done this morning as I can before signing off. I'll try not to completely break things on the way out the door....


Copy link

New Mike Driscoll Book - The Python Quiz Book!

I'm excited that I received the latest Mike Driscoll book in the mail today.


I like Mike's books on numerous levels. The style is right up my alley and stickers with his books, and now puzzles too?! FUN... and I like fun!

This one is really interesting and a little different than his others. I love it! It's clever. It can be a "I've got 3 minutes while waiting to pick up the kids so pull it out and give one of the quizzes a try" book.

The answers/hints to the quizzes include the location you will find the information in the Python documentation so you've got a place to go diving deeper if you want.

I start here with Mike's sites as he's got a lot going on now with his newer and growing site too:

Here's a page about the specific book:

Of anyone I've met in the Python community.... I've not met someone that's been in it for SOOO long, has written so much material and is also one of THE nicest persons I've encountered. His positive attitude permeates his books, his websites, and his Twitter account. So, for sure go check him out!

Copy link

Slowed Pace.....

As I mentioned a couple of weeks ago, there have been several personal issues that are pulling me away from the project. It's frustrating, to say the least, as the year-long work on the upcoming release is nearing completion. Several medical complications have also significantly impacted my ability to work. I'm sorry for any impact that may have on your project and for the impact on the pace of PySimpleGUI overall. I'm doing all I can to recover and look forward to getting back to working hard as I can on the project.

Copy link

Getting Back Up To Speed....

I'm feeling better and am able to work several hours a day again. @jason990420 has been a hero of this project, not just recently while I've been out, but for the past several years. He deserves a massive round of applause for his non-stop commitment to helping so many people here.

I'll be getting back into the issues this weekend. I'm still splitting time between the currently publicly released project and the much larger release on the way. We're getting closer by the day.

I again apologize for the absence. I love this project, the users, and have missed working on it.... so it's nice to finally be able to spend some focused time on it again! Hopefully will get to these new issues in the next 2 days.

Thank you everyone for the support. It means more than I can express in words.


Copy link

PySimpleGUI commented Apr 2, 2023

Launcher Code For Chat....

I've written plenty on the AI Chat tools. Like everyone is learning, it's new territory to be explored. There are plenty of wonderful uses of this technology and I like Bing's implementation, particularly since I get the underlying "sources". While it can "generate code", I think the shorter snippet the better.

I like my own "Launchers" written in PySimpleGUI that I leave running. I've got 40 or so programs running at all times that monitor weather where my friends live, my CPU usage, 2 different launchers so I click 1 button and something kicks off like a "Build", etc.

I wanted a button that would open Edget to the BingChat so that I didn't have to open Edge, click a saved link, etc. This line of PySimpleGUI code is all that's needed to launch Edge to the Bing Chat page... at least on my system:

sg.execute_command_subprocess(r'start', 'msedge','""')

LED Weather Widget

One of the Demo Programs has stopped functioning... the long-term weather that's located here:

You'll find it at the bottom of this image:

I found that the reason that it is no longer working can be found here:

which has the message at the top:


Will have to get this one converted at some point... but not super important at the moment... just an FYI...

Copy link

New 3.0 Version of psgtest Released to PyPI

A lot of testing is required for the new release that's coming soon. Testing and stability have been an important part of PySimpleGUI releases since the initial release in July 2018. This release needs to be thoroughly tested on all releases of Python, from 3.6 through 3.12.

To aid in the testing, the psgtest utility was expanded to perform automated testing using multiple interpreters. The "Run Regression All Interpreters" button will test the selected programs on every interpreter you've configured in the settings.

A tip for using on your development machine

If you want to run stress tests while you continue to work on your computer then try making your test programs have no_titlebar=True. I've found that this has much lower impact on Windows as an icon is not created on the taskbar for these windows. Explorer seems to be much happier and run much smoother without having to create and destroy icons on the taskbar.


Copy link

PySimpleGUI 5.0 Almost Done

For the past year I've been talking about splitting my time between the current version of PySimpleGUI and a larger release of PySimpleGUI that includes a rewrite of the documentation. We're getting close to completing this release.

I would like to share a bit of what's coming in this release. More details are coming as the release nears completion.

I'm sure you can understand the amount of testing that's involved in a large release of PySimpleGUI. There are multiple OS's, versions of Python, versions of tkinter, support on devices like the Raspberry Pi and online environments like Trinket. The stability of PySimpleGUI has and remains an extremely important part of the PySimpleGUI user experience. I don't like crashes and I'm sure our users don't like them either.

Backward Compatible

Of course, 5.0 is backward compatible with previous releases of PySimpleGUI.


The docs have all been rewritten. The interface is greatly improved with a much better and more manageable table of contents with sections that expand and collapse.

All 4 ports now have an SDK call reference, which also means all 4 ports have a full set of Docstrings so that your IDE understands the PySimpleGUI interfaces, providing you better code completion and error checking.

The eCookbook is now a part of the documentation (a new tab). Rather than visiting the Trinket site, you're able to run PySimpleGUI code directly from the PySimpleGUI documentation. Not only does the eCookbook take advantage of this new capability, so does the main documentation.

Enhanced Security

Several companies have voiced concern about security and being able to verify that PySimpleGUI code is "authentic".

There is a self-check in the code that authenticates the code is a valid "signed" release every time you import PySimpleGUI. There are web-based tools that enable you to be absolutely certain the code has not been tampered with since the self-check code, while made tamper-resistant, could in theory be modified.

Simplified Pip Installs and Upgrades

We're restructuring the GitHub repos for the PySimpleGUI project and have been using a new installation and upgrade architecture that has been working well during development. You'll be able to use the built-in "Upgrade From GitHub" feature as you do today, as well as using pip by itself in a more standard way.

There are also a number of utilities included in 5.0 that help with installing PySimpleGUI as well as other Python packages. A utility to help you with releasing your own code using this design will be released with 5.0.

Intelligent Upgrade Service

It's been a challenge to synchronize PySimpleGUI releases with OS and tkinter releases, particularly on the Mac. To improve stability and user experience, we've developed an Intelligent Upgrade Service to inform users when there are releases of PySimpleGUI that fix a problem that may be unique to their combination of components.

This is important when someone upgrades their OS which causes a problem with tkinter and PySimpleGUI. We'll be able to detect when they have a known bad configuration and provide instructions for which version of PySimpleGUI will work best given their new environment.

New Features

There are a number of new features are in 5.0 that are not in the GitHub port. The User Settings API has been expanded so that it's better integrated with your layout. It makes working data that persists between runs. For example, a parameter was added to the Window object that will automatically save the last location you had your windows located and will open it to that location the next time you run the program.

Your Patience Has Been Fantastic

I really appreciate the patience everyone has shown while this development work has been happening. We've done our best to keep bug fixes and some enhancements being added while working on 5.0. It's been much easier with your help.

Copy link

4.60.5 Posting to PyPI this weekend. 5.0 In June or PySimpleGUI 5 Year Anniversary at the Latest

We're posting a dot-release to PyPI this weekend that addresses 2 Mac issues. Those 2 issues are:

  1. Input Element doesn't work for no-titlebar windows on MacOS 13.2.1
  2. Narrowed the Alpha Channel 0.99 fix for disappearing window to be only on tkinter 8.6.12. This removes the need for anyone to uncheck the setting in the Mac Control Panel

Release notes will be posted once we're done testing and have uploaded to PyPI.

5.0 is looking good for June. The 5-year anniversary since the initial release of PySimpleGUI is July 7th (I think that's the right day). I would like to be done prior to that date. It's exciting to be getting close, but still a lot to do so I'm sorry if I'm distracted while we're trying to get it all wrapped up.

Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
All Ports All Ports announcements Announcements
None yet

No branches or pull requests

16 participants