PyQtGraph plotting over time — Updating plots in real time with PyQtGraph and PyQt6

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

One of the most common things people want to do with PyQtGraph is display data that updates over time — like an oscilloscope trace, a live sensor feed, or a streaming signal. The plot scrolls continuously as new data arrives, with old data dropping off the left side.

In this tutorial, you'll learn how to create a real-time scrolling plot using PyQtGraph and PyQt6. We'll start with a static plot, then animate it with a QTimer so it updates on a fixed interval. By the end, you'll have a working template you can adapt for your own live data sources.

Setting up a basic plot

Before we animate anything, let's get a simple PyQtGraph plot on screen. If you haven't already installed PyQtGraph, you can do so with pip:

bash

pip install pyqtgraph PyQt6

Here's a minimal example that creates a window with a plot widget and draws a static line:

python

from PyQt6 import QtWidgets
import pyqtgraph as pg
import sys


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

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

        x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        y = [30, 32, 34, 32, 33, 31, 29, 32, 35, 45]

        self.graphWidget.plot(x, y)


app = QtWidgets.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec())

Run this and you'll see a window with a single line plotted from your data. That's your starting point — now let's make it move.

Updating the plot with a QTimer

To create a scrolling, real-time effect, we need two things:

A reference to the plotted line, so we can update its data later.
A timer that fires at regular intervals and triggers a data update.

When you call self.graphWidget.plot(...), it returns a PlotDataItem object — a reference to the line that was just drawn. By holding onto that reference, you can call .setData() on it later to replace the data with new values. This redraws the line without creating a new one, which is both clean and efficient.

For the timer, Qt provides QTimer. You connect its timeout signal to a function, set an interval in milliseconds, and start it. Every time the interval elapses, your function runs.

Here's how it looks in practice:

python

from PyQt6 import QtWidgets, QtCore
import pyqtgraph as pg
import sys
from random import randint


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

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

        self.x = list(range(100))  # 100 time points
        self.y = [randint(0, 100) for _ in range(100)]  # 100 data points

        self.graphWidget.setBackground("w")

        pen = pg.mkPen(color=(255, 0, 0))
        self.data_line = self.graphWidget.plot(self.x, self.y, pen=pen)

        self.timer = QtCore.QTimer()
        self.timer.setInterval(50)
        self.timer.timeout.connect(self.update_plot_data)
        self.timer.start()

    def update_plot_data(self):
        self.x = self.x[1:]  # Remove the first x element.
        self.x.append(self.x[-1] + 1)  # Add a new value 1 higher than the last.

        self.y = self.y[1:]  # Remove the first y element.
        self.y.append(randint(0, 100))  # Add a new random value.

        self.data_line.setData(self.x, self.y)  # Update the data.


app = QtWidgets.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec())

Run this and you'll see a red line scrolling across the screen, updating every 50 milliseconds with new random values. It already looks like a live data feed.

Let's walk through what's happening in update_plot_data:

self.x = self.x[1:] — removes the oldest time point from the front of the list.
self.x.append(self.x[-1] + 1) — adds a new time point at the end, one step beyond the previous last value. This keeps the x-axis advancing forward.
The same pattern applies to self.y — drop the oldest value, add a new one.
self.data_line.setData(self.x, self.y) — redraws the line with the updated data.

The lists always stay the same length (100 elements), so the plot shows a fixed-width window of data that slides forward over time. This is the scrolling effect.

Adjusting the speed and window size

You can easily tune this to match your needs:

Change the update speed by adjusting self.timer.setInterval(). The value is in milliseconds, so 50 means 20 updates per second. Use 100 for 10 updates/second, or 1000 for once per second.
Change the visible window size by adjusting the initial length of self.x and self.y. Using list(range(500)) and 500 data points gives you a wider view of the data history.

For example, to show 200 data points updating once every 100ms:

python

self.x = list(range(200))
self.y = [randint(0, 100) for _ in range(200)]
# ...
self.timer.setInterval(100)

Using numpy for better performance

The example above uses plain Python lists, which works well for moderate data sizes. If you're working with large amounts of data or need fast update rates, using NumPy arrays and np.roll() can give you a significant performance boost.

The np.roll() function shifts all elements in an array by a given number of positions, wrapping values from one end to the other. For a scrolling plot, you roll the array by -1 (shifting everything one position to the left) and then overwrite the last element with the new value:

python

import numpy as np

data = np.array([10, 20, 30, 40, 50])
data = np.roll(data, -1)
# data is now [20, 30, 40, 50, 10]
data[-1] = 60
# data is now [20, 30, 40, 50, 60]

Here's the full example rewritten with NumPy:

python

from PyQt6 import QtWidgets, QtCore
import pyqtgraph as pg
import numpy as np
import sys


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

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

        self.x = np.arange(100)  # 100 time points
        self.y = np.random.randint(0, 100, size=100)  # 100 random data points

        self.graphWidget.setBackground("w")

        pen = pg.mkPen(color=(255, 0, 0))
        self.data_line = self.graphWidget.plot(self.x, self.y, pen=pen)

        self.timer = QtCore.QTimer()
        self.timer.setInterval(50)
        self.timer.timeout.connect(self.update_plot_data)
        self.timer.start()

    def update_plot_data(self):
        self.x = np.roll(self.x, -1)
        self.x[-1] = self.x[-2] + 1

        self.y = np.roll(self.y, -1)
        self.y[-1] = np.random.randint(0, 100)

        self.data_line.setData(self.x, self.y)


app = QtWidgets.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec())

The behavior is identical — a scrolling red line with random data — but the array operations are faster under the hood. For 100 points, you won't notice a difference. For thousands of points at high update rates, NumPy makes a real difference.

Connecting to an external data source

In the examples so far, we've generated random data inside update_plot_data. In a real application, your data will come from somewhere else — a sensor, a file, a network socket, or another part of your program.

The pattern stays the same: in your timer callback, you fetch the latest value from wherever your data lives, and feed it into the plot. Here's an example that reads from an external data source (simulated here with a simple class):

python

from PyQt6 import QtWidgets, QtCore
import pyqtgraph as pg
import numpy as np
import sys


class DataSource:
    """Simulates an external data source that provides readings."""

    def __init__(self):
        self.offset = 0

    def get_reading(self):
        """Return a simulated sensor reading."""
        self.offset += 0.1
        return 50 + 30 * np.sin(self.offset) + np.random.normal(0, 3)


class MainWindow(QtWidgets.QMainWindow):
    def __init__(self, data_source):
        super().__init__()

        self.data_source = data_source

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

        self.x = np.arange(200)
        self.y = np.zeros(200)

        self.graphWidget.setBackground("w")
        self.graphWidget.setTitle("Live Sensor Data")
        self.graphWidget.setLabel("left", "Amplitude")
        self.graphWidget.setLabel("bottom", "Time")

        pen = pg.mkPen(color=(255, 0, 0), width=2)
        self.data_line = self.graphWidget.plot(self.x, self.y, pen=pen)

        self.timer = QtCore.QTimer()
        self.timer.setInterval(50)
        self.timer.timeout.connect(self.update_plot_data)
        self.timer.start()

    def update_plot_data(self):
        self.x = np.roll(self.x, -1)
        self.x[-1] = self.x[-2] + 1

        self.y = np.roll(self.y, -1)
        self.y[-1] = self.data_source.get_reading()

        self.data_line.setData(self.x, self.y)


app = QtWidgets.QApplication(sys.argv)
source = DataSource()
w = MainWindow(source)
w.show()
sys.exit(app.exec())

The DataSource class here is a stand-in. In your own project, you'd replace get_reading() with whatever code fetches data from your actual source — reading from a serial port, polling a web API, or pulling from a shared queue.

The plot window receives the DataSource as a dependency, keeping the data logic separate from the display logic. This makes it straightforward to swap in a different data source later without changing the plotting code.

If your data source is slow or blocking (for example, a network request), you should consider running it in a separate thread to avoid freezing the UI. See our guide on multithreading PyQt6 applications with QThreadPool for how to handle this.

Displaying different time windows

If you want to show the same data stream at different zoom levels — say, the last 5 seconds and the last 30 seconds — you can use multiple PlotWidget instances, each with its own data buffer. To arrange them vertically, we use a QVBoxLayout.

Here's an example with two plots, each showing a different time window from the same data source:

python

from PyQt6 import QtWidgets, QtCore
import pyqtgraph as pg
import numpy as np
import sys


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

        layout = QtWidgets.QVBoxLayout()

        # Short window: 100 points (5 seconds at 50ms interval)
        self.graph_short = pg.PlotWidget()
        self.graph_short.setBackground("w")
        self.graph_short.setTitle("Last 5 seconds")
        layout.addWidget(self.graph_short)

        # Long window: 600 points (30 seconds at 50ms interval)
        self.graph_long = pg.PlotWidget()
        self.graph_long.setBackground("w")
        self.graph_long.setTitle("Last 30 seconds")
        layout.addWidget(self.graph_long)

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

        self.x_short = np.arange(100)
        self.y_short = np.zeros(100)

        self.x_long = np.arange(600)
        self.y_long = np.zeros(600)

        pen = pg.mkPen(color=(255, 0, 0), width=2)
        self.line_short = self.graph_short.plot(
            self.x_short, self.y_short, pen=pen
        )
        self.line_long = self.graph_long.plot(
            self.x_long, self.y_long, pen=pen
        )

        self.timer = QtCore.QTimer()
        self.timer.setInterval(50)
        self.timer.timeout.connect(self.update_plot_data)
        self.timer.start()

    def update_plot_data(self):
        new_value = np.random.randint(0, 100)

        # Update short window.
        self.x_short = np.roll(self.x_short, -1)
        self.x_short[-1] = self.x_short[-2] + 1
        self.y_short = np.roll(self.y_short, -1)
        self.y_short[-1] = new_value
        self.line_short.setData(self.x_short, self.y_short)

        # Update long window.
        self.x_long = np.roll(self.x_long, -1)
        self.x_long[-1] = self.x_long[-2] + 1
        self.y_long = np.roll(self.y_long, -1)
        self.y_long[-1] = new_value
        self.line_long.setData(self.x_long, self.y_long)


app = QtWidgets.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec())

Both plots receive the same data point on each tick. The short plot shows a zoomed-in view (the last 5 seconds), while the long plot shows a wider history (the last 30 seconds). You could extend this pattern to show even longer windows — minutes or hours — by increasing the buffer size and adjusting the timer interval or down-sampling the data for the longer views.

Complete working example

Here's the full, polished version with a white background, labeled axes, and a clean structure you can use as a starting point for your own projects:

python

from PyQt6 import QtWidgets, QtCore
import pyqtgraph as pg
import numpy as np
import sys


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

        self.setWindowTitle("Real-Time PyQtGraph Plot")

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

        # Configure the plot appearance.
        self.graphWidget.setBackground("w")
        self.graphWidget.setTitle(
            "Live Data", color="k", size="14pt"
        )
        self.graphWidget.setLabel("left", "Amplitude")
        self.graphWidget.setLabel("bottom", "Time (samples)")
        self.graphWidget.showGrid(x=True, y=True)

        # Initialize data arrays.
        self.buffer_size = 200
        self.x = np.arange(self.buffer_size)
        self.y = np.zeros(self.buffer_size)

        # Create the plot line and keep a reference.
        pen = pg.mkPen(color=(255, 0, 0), width=2)
        self.data_line = self.graphWidget.plot(self.x, self.y, pen=pen)

        # Set up a timer to update the plot.
        self.timer = QtCore.QTimer()
        self.timer.setInterval(50)  # 50ms = 20 updates per second
        self.timer.timeout.connect(self.update_plot_data)
        self.timer.start()

    def update_plot_data(self):
        # Scroll the x-axis forward.
        self.x = np.roll(self.x, -1)
        self.x[-1] = self.x[-2] + 1

        # Add a new data point (replace with your data source).
        self.y = np.roll(self.y, -1)
        self.y[-1] = np.random.randint(0, 100)

        # Redraw the line with updated data.
        self.data_line.setData(self.x, self.y)


app = QtWidgets.QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec())

To adapt this for your own data, replace the np.random.randint(0, 100) line in update_plot_data with a call to whatever provides your actual data. Everything else — the scrolling, the display, the timer — stays the same.

If you want to embed PyQtGraph plots as custom widgets within a larger Qt application, you can integrate them alongside other UI elements using Qt Designer or code-based layouts.

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

Python GUIs - real-time

PyQtGraph plotting over time — Updating plots in real time with PyQtGraph and PyQt6

Setting up a basic plot

Updating the plot with a QTimer

Adjusting the speed and window size

Using numpy for better performance

Connecting to an external data source

Displaying different time windows

Complete working example