Python GUIs - spyder

PyQt Windows Won't Reopen in Spyder — How to Fix It — Why your PyQt app only runs once in Spyder, and what you can do about it

2021-01-30T09:00:00+00:00

I'm using Spyder in Anaconda to learn PyQt5. The first time I run my code, the Qt window pops up fine. But after I close the window and try to run the code again, nothing happens — no window, no error, nothing. I have to completely restart Spyder every time. Why does this happen?

This is one of the most common problems people run into when starting out with PyQt in Spyder, so if you've hit this wall, you're in good company. The good news is that it's not a problem with your code — it's a known quirk of how Spyder's IPython console interacts with the Qt event loop.

Why This Happens

When you run a PyQt application, a key part of the process is starting the Qt event loop by calling app.exec(). This event loop is what keeps your window open, responds to clicks and keypresses, and generally makes your GUI work. If you're new to this concept, our tutorial on signals, slots, and events covers how the event loop drives a PyQt application.

In a normal Python script run from a terminal, calling app.exec() starts the event loop, and when you close the window, the loop ends and the script finishes cleanly. The next time you run the script, everything starts fresh.

Spyder uses an embedded IPython console, and IPython has its own integration with Qt's event loop. When your script calls QApplication(), it creates an application instance inside that console session. After you close the window and the event loop ends, things aren't fully cleaned up — the old QApplication instance still exists in memory. When you try to run the script again, Qt sees that an application already exists and doesn't create a new one properly, so your window never appears.

Solutions

There are several ways to work around this. Pick the one that fits your workflow best.

Use `%gui qt` magic in the IPython Console

Spyder's IPython console supports a special command that tells IPython to manage the Qt event loop for you. Before running your script, type the following into Spyder's IPython console:

python

%gui qt

This tells IPython to integrate with Qt's event loop. With this active, you may also need to adjust your script so it doesn't call app.exec() itself (since IPython is already running the event loop). For example:

python

import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QLabel

app = QApplication.instance()
if app is None:
    app = QApplication(sys.argv)

window = QMainWindow()
window.setCentralWidget(QLabel("Hello, PyQt!"))
window.show()

The QApplication.instance() check is the important part here — it reuses the existing application object if one already exists, instead of trying to create a second one (which Qt doesn't allow).

Change the Run Configuration

You can tell Spyder to run your script in a fresh, dedicated Python process instead of the built-in IPython console. This avoids the event loop conflict entirely.

Go to Run → Configuration per file (or press Ctrl+F6).
Under Console, select Execute in an external system terminal.
Click OK and run your script.

Now each time you run the script, it starts in a clean process — just like running it from a terminal. The window will appear in its own process, and you can re-run as many times as you like.

Use Run → Profile

As discovered in the original forum thread, using Run → Profile instead of the normal Run command also works around this issue. Profiling runs the script in a separate process, which avoids the stale QApplication problem. This is a quick workaround, though it's not really what profiling is designed for.

Run from the Terminal

The most reliable way to develop PyQt applications is to run them directly from a terminal or command prompt. In your terminal, navigate to the folder containing your script and run:

bash

python my_app.py

Each run starts a completely fresh Python process, so you'll never hit the stale event loop issue. You can still use Spyder (or any other editor) to write and edit your code — just switch to the terminal to run it.

A Complete Working Example

Here's a minimal PyQt6 application that you can use to test any of the solutions above. If you need help setting up PyQt6 first, see our guide on creating your first PyQt6 window.

python

import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QPushButton, QVBoxLayout, QWidget


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("PyQt in Spyder — Test")

        button = QPushButton("Click me!")
        button.clicked.connect(self.on_button_clicked)

        layout = QVBoxLayout()
        layout.addWidget(button)

        container = QWidget()
        container.setLayout(layout)
        self.setCentralWidget(container)

    def on_button_clicked(self):
        print("Button was clicked!")


app = QApplication(sys.argv)
window = MainWindow()
window.show()
app.exec()

If you're running this inside Spyder's IPython console and want to be able to re-run without restarting, replace the last three lines with:

python

app = QApplication.instance()
if app is None:
    app = QApplication(sys.argv)

window = MainWindow()
window.show()

Which Approach Should I Use Long-Term?

For learning and day-to-day development, running your scripts from a terminal is the most straightforward option. It eliminates any IDE-specific quirks and ensures your application behaves exactly the way it will for your users. You can use Spyder (or VS Code, PyCharm, or any text editor you like) for writing code, and simply keep a terminal window open alongside it for running your scripts.

If you prefer to stay entirely within Spyder, using the external terminal run configuration is the cleanest fix, since it doesn't require any changes to your actual code.

For an in-depth guide to building Python GUIs with PyQt6 see my book, Create GUI Applications with Python & Qt6.

PyQtGraph errors in Spyder/IPython — Fixing common PyQtGraph color, font size, and compatibility issues

2020-05-07T09:00:00+00:00

If you're working through PyQtGraph tutorials and running into errors when setting colors, titles, or font sizes, you're not alone. These issues come up frequently, especially when using older versions of PyQtGraph in environments like Spyder or IPython. The good news is that most of these problems have straightforward fixes.

In this article, we'll walk through the most common PyQtGraph errors related to colors and label formatting, explain why they happen, and show you how to solve them.

The color name error

You might see this error when trying to set a title color using a full color name like 'blue':

python

self.graphWidget.setTitle("Your Title Here", color='blue', size='30pt')

python

File "...\pyqtgraph\functions.py", line 182, in mkColor
    g = int(c[1]*2, 16)
ValueError: invalid literal for int() with base 16: 'll'

Or, when using 'black':

python

UnboundLocalError: local variable 'r' referenced before assignment

These errors occur because older versions of PyQtGraph's mkColor function don't understand full color names like 'blue' or 'black'. When you pass 'blue', PyQtGraph tries to interpret it as a hex color string, picks out individual characters ('l', 'u', etc.), and fails to parse them as hexadecimal values.

The fix: use single-letter color codes or update PyQtGraph

The simplest immediate fix is to use PyQtGraph's single-letter color codes instead of full color names:

Letter	Color
`'r'`	Red
`'g'`	Green
`'b'`	Blue
`'c'`	Cyan
`'m'`	Magenta
`'y'`	Yellow
`'k'`	Black
`'w'`	White

So instead of color='blue', use color='b':

python

self.graphWidget.setTitle("Your Title Here", color="b", size="30pt")

You can also pass colors as hex strings or RGB tuples:

python

# Hex color
self.graphWidget.setTitle("Your Title Here", color="#0000FF", size="30pt")

# RGB tuple (values 0-255)
self.graphWidget.setTitle("Your Title Here", color=(0, 0, 255), size="30pt")

The better long-term fix is to update PyQtGraph to a newer version, where full color name support has been improved:

bash

pip install pyqtgraph --upgrade

The font size TypeError

Another common error appears when passing the size parameter as an integer:

python

self.graphWidget.setTitle("Your Title Here", color="b", size=30)

python

File "...\pyqtgraph\graphicsItems\LabelItem.py", line 61, in setText
    optlist.append('font-size: ' + opts['size'])
TypeError: can only concatenate str (not "int") to str

This happens because PyQtGraph's LabelItem.setText method builds a CSS style string internally. It expects the size value to already be a string with a unit suffix like '30pt'. When you pass the integer 30, Python can't concatenate a string and an integer.

The fix: pass size as a string with units

Always pass the size parameter as a string that includes the CSS unit:

python

self.graphWidget.setTitle("Your Title Here", color="b", size="30pt")

The pt suffix stands for "points," which is a standard CSS font-size unit. You could also use px (pixels) if you prefer:

python

self.graphWidget.setTitle("Your Title Here", color="b", size="30px")

Updating PyQtGraph

Many of these issues were fixed in later releases of PyQtGraph. If you're using an older version (especially anything before 0.11), upgrading will resolve most of these problems and give you access to better features and performance.

Check your current version:

bash

pip show pyqtgraph

Upgrade to the latest version:

bash

pip install pyqtgraph --upgrade

If you're using Anaconda (common with Spyder), you can also update through conda:

bash

conda install -c conda-forge pyqtgraph

The `time.clock` error

If you're on Python 3.8 or later with an older PyQtGraph version, you may also see an error related to time.clock. This function was removed in Python 3.8. Upgrading PyQtGraph to version 0.11.0 or later fixes this as well.

A complete working example

Here's a complete example that uses the correct color and size formats, and should work across PyQtGraph versions:

python

import sys

from PyQt5.QtWidgets import QApplication, QMainWindow

import pyqtgraph as pg


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        self.graphWidget = pg.PlotWidget()
        self.setCentralWidget(self.graphWidget)

        # Set background color
        self.graphWidget.setBackground("w")

        # Set title with single-letter color code and string size
        self.graphWidget.setTitle(
            "Temperature Over Time", color="b", size="20pt"
        )

        # Set axis labels
        styles = {"color": "r", "font-size": "18px"}
        self.graphWidget.setLabel("left", "Temperature (°C)", **styles)
        self.graphWidget.setLabel("bottom", "Time (min)", **styles)

        # Add grid
        self.graphWidget.showGrid(x=True, y=True)

        # Sample data
        hour = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        temperature = [30, 32, 34, 32, 33, 31, 29, 32, 35, 30]

        # Plot with a blue pen
        pen = pg.mkPen(color="b", width=2)
        self.graphWidget.plot(hour, temperature, pen=pen)


app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())

This example avoids all the common pitfalls:

Colors use single-letter codes ("b", "r") instead of full names
The title size is a string with a unit ("20pt")
Axis label styles use string values with units ("18px")

If you run this and see your plot with a blue title, red axis labels, and a line chart, everything is working correctly.

Summary of fixes

Error	Cause	Fix
`ValueError: invalid literal for int() with base 16`	Full color name like `'blue'` not supported	Use `'b'` or a hex/RGB value
`UnboundLocalError: local variable 'r' referenced before assignment`	Unrecognized color string	Use single-letter codes, hex, or RGB tuples
`TypeError: can only concatenate str (not "int") to str`	Size passed as integer (`30`)	Pass as string with unit (`"30pt"`)
`AttributeError: module 'time' has no attribute 'clock'`	Python 3.8+ with old PyQtGraph	Upgrade PyQtGraph to 0.11.0+

When in doubt, upgrading PyQtGraph to the latest version is the single most effective thing you can do. Most of these quirks have been addressed in recent releases, and you'll benefit from better compatibility with modern Python and Qt versions.

For an in-depth guide to building Python GUIs with PyQt5 see my book, Create GUI Applications with Python & Qt5.

Spyder IDE gets stuck when running PyQt5 applications — How to fix the frozen console and unresponsive window problem in Spyder

2020-05-07T09:00:00+00:00

If you're following a PyQt5 tutorial and running your code in Spyder, you may have hit an annoying problem: the console freezes as soon as your window appears, clicking the close button ("x") doesn't work, and you're forced to restart the kernel. This is a well-known issue with how Spyder handles Qt event loops, and the fix is straightforward.

Why does this happen?

Spyder itself is built with PyQt5. It runs its own Qt event loop behind the scenes to power its interface. When you launch a second PyQt5 application from within Spyder — your application — the two event loops can conflict with each other, causing the console to lock up and your window to become unresponsive.

The typical code that triggers this looks something like:

python

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow

app = QApplication(sys.argv)

window = QMainWindow()
window.show()

app.exec()

Running this in Spyder can cause the IDE to hang because app.exec() starts a blocking event loop that clashes with Spyder's own loop. If you're just getting started with PyQt5, see our tutorial on creating your first PyQt window for the basics of how QApplication and the event loop work.

The fix: change Spyder's graphics backend

Spyder has a built-in setting that lets it share its own Qt event loop with your application. When this is enabled, you don't need to create your own QApplication or call app.exec() — Spyder takes care of it for you.

Here's how to enable it:

In Spyder, go to Tools → Preferences (or Python → Preferences on macOS).
Select IPython console from the left-hand panel.
Click on the Graphics tab.
Under Graphics backend, change the dropdown to Qt5.
Click OK and restart the kernel (go to Consoles → Restart kernel, or press the restart button in the console toolbar).

After doing this, Spyder's IPython console will integrate with the Qt event loop automatically.

Adjusting your code for Spyder

With the Qt5 backend enabled, you'll want to modify your code slightly so it works both inside Spyder and as a standalone script. The main change is to check whether a QApplication instance already exists before creating a new one:

python

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow

app = QApplication.instance()
if app is None:
    app = QApplication(sys.argv)

window = QMainWindow()
window.setWindowTitle("My Window")
window.show()

app.exec()

QApplication.instance() returns the existing application object if one is already running (which it will be inside Spyder with the Qt5 backend). If there isn't one — for example, when you run the script from a terminal — it creates a new one as usual.

This pattern means your script will work correctly in both environments.

Alternative: run your scripts externally

If you'd rather not change Spyder's settings, another option is to run your PyQt5 scripts in an external terminal instead of Spyder's built-in console.

Go to Run → Configuration per file (or press Ctrl+F6).
Under Console, select Execute in an external system terminal.
Click OK and run the script.

Your PyQt5 application will open in a separate process, completely independent of Spyder's event loop. This avoids the conflict entirely and behaves the same as running python your_script.py from a terminal.

You might also consider using a different IDE altogether. VS Code and PyCharm are both popular alternatives that don't share a Qt event loop with your application, so they avoid this issue entirely.

Summary

The freezing issue happens because Spyder and your PyQt5 application both try to run their own Qt event loops. You can fix it by either:

Setting Spyder's graphics backend to Qt5, which lets Spyder manage the event loop for you.
Running your script in an external terminal, which keeps the two processes separate.

Both approaches work well. The graphics backend approach is convenient for quick experimentation in the console, while the external terminal approach keeps your code identical to what you'd run outside of Spyder. Pick whichever fits your workflow best.

If you're considering upgrading to PyQt6 or PySide6 for your projects, take a look at our comparison of PyQt6 vs PySide6 to help you decide which is right for you.

For an in-depth guide to building Python GUIs with PySide6 see my book, Create GUI Applications with Python & Qt6.

Python GUIs - spyder

PyQt Windows Won't Reopen in Spyder — How to Fix It — Why your PyQt app only runs once in Spyder, and what you can do about it

Why This Happens

Solutions

Use %gui qt magic in the IPython Console

Change the Run Configuration

Use Run → Profile

Run from the Terminal

A Complete Working Example

Which Approach Should I Use Long-Term?

PyQtGraph errors in Spyder/IPython — Fixing common PyQtGraph color, font size, and compatibility issues

The color name error

The fix: use single-letter color codes or update PyQtGraph

The font size TypeError

The fix: pass size as a string with units

Updating PyQtGraph

The time.clock error

A complete working example

Summary of fixes

Spyder IDE gets stuck when running PyQt5 applications — How to fix the frozen console and unresponsive window problem in Spyder

Why does this happen?

The fix: change Spyder's graphics backend

Adjusting your code for Spyder

Alternative: run your scripts externally

Summary

Use `%gui qt` magic in the IPython Console

The `time.clock` error