What are the best desktop libraries for IoT data visualization with examples?

Nowadays IoT sensors generate streams of data every second – from temperature, humidity to energy consumptions, object detection incidents and much more. Analyzing the raw data does not give the full picture. To better understand dependencies and draw conclusions, it is worth using dedicated desktop libraries for IoT data visualization.

The example data slice contains the hourly averaged responses of a gas multisensor device:

This is just a slice of the full collection, which includes 9357 records. Even in such a small dataset, analysis of the raw measurements is difficult to perform.

Measurement data from a single sensor collected for a month form a huge collection – that’s 43,200 lines when recording every minute, or as many as 2,592,000 lines when recording every second. In real-live deployments, the number of sensors often exceeds several thousand. Analyzing such extensive data sets without the use of appropriate tools and methods quickly becomes almost impossible.

Therefore, in this article, we will present desktop libraries for effective IoT data visualizations. Desktop libraries offer a powerful and accessible solution, enabling developers and data scientists to activate the full potential of IoT data directly on their local machines. We will explore various categories of these libraries, examining their unique strengths, functionalities, and showing examples of usages.

Desktop vs web libraries: Which is better for IoT data visualization?

Although web libraries such as D3.js and Chart.js are great for interactive dashboards, and if you’re interested in a deeper dive into the strengths and use cases of web-based visualization tools, be sure to check out our dedicated article on web libraries for data visualization. However when we need powerful rendering, advanced personalization, and reliable report automation, desktop solutions are still irreplaceable.

But what makes desktop libraries such a compelling choice for IoT data visualization, especially when working with large, complex datasets? Let’s take a closer look at their unique advantages:

Performance

Desktop libraries are optimized for rendering directly on the local machine, using graphics engines (Agg, Qt, GTK) or GPU acceleration. As a result, visualizations with a large number of points, lines or geometric objects generate faster and smoother, without the delays associated with JavaScript code interpretation or browser limitations.
In addition, tools such as PyQtGraph or VisPy offer data paging and GPU caching mechanisms, allowing millions of points to be viewed interactively in real time without risking memory overload.

More control

Desktop libraries for IoT data visualization (e.g., Matplotlib, Seaborn, Cartopy) provide a low-level API for customizing every detail of a chart with precision: line styles, markers, axis layouts, labels or color gradients. In contrast, web libraries often operate on ready-made themes and simplified interfaces, which limits creative freedom.
With the ability to write custom renderers, we can easily implement corporate visual conventions or custom graphic effects. In a local environment, it’s also simpler to integrate charts with other tools, export them to SVG or generate PDF reports.

Faster prototyping and automation

Scripts based on Matplotlib, Seaborn or Plotly can be seamlessly combined into ETL pipelines, run on a schedule from the cron level or integrated with CI/CD (e.g. GitLab CI, Jenkins).
In addition, the ability to create animations (for example, using matplotlib.animation) allows you to quickly prototype interactive presentations or videos to visualize changes in your data – without the need to deploy a web server.

Data privacy and security

Working with desktop visualization libraries ensures that all data remains exclusively on your computer – it is not transferred to external servers or the cloud. This is crucial for projects that require the protection of sensitive information (such as medical or financial data) and for meeting industry regulations. In addition, the local environment allows for easy use of encryption of visualization results files and control of access to reports, eliminating the risk of unauthorized viewing or data leakage.

What are the top desktop libraries for IoT data visualization?

Here are some of the most commonly used desktop libraries for data visualization in Python. They feature high performance, flexibility and intuitive operation, enabling both simple line graphs and GPU-accelerated 3D point clouds, executed locally.

Matplotlib

The Matplotlib Python library is one of the most popular tools for creating data visualizations, originally developed by John D. Hunter in 2003. It enables users to generate a wide variety of charts including line charts, bar charts, pie charts, histograms, dot plots, and even more advanced 3D visualizations all with a high degree of customization. It offers a lot of control over each chart element, allowing you to customize colors, fonts, labels, axes, legends and other visual properties. The library is open source and continuously developed by the developer community, which ensures regular updates, bug fixes and new functionality.

Best uses for Matplotlib:

Lightweight builds for constrained devices – few dependencies, can be easily built even on resource constrained machines.
Admin dashboards vs end-user simple UI – great for generating static PDF/PNG reports for internal teams.
Customization with customer branding – full control over chart elements allows easy incorporation of logos, fonts and company colors.

Usage Example of Matplotlib:

An image contains two subplots, where the first is a line plot comparing two sensor readings over time and the seconds is a scatter plot showing the relationship between CO (Carbon Monoxide) and NMHC (Non-Methane Hydrocarbon) sensors. It was created using presented code snippet:

				
					import pandas as pd
import matplotlib.pyplot as plt

# Read the CSV file
df = pd.read_csv('dataset.csv')

# Create figure with 2 subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# Subplot 1: Line plot
ax1.plot(df['PT08.S1(CO)'], label='CO Sensor', color='red')
ax1.plot(df['PT08.S2(NMHC)'], label='NMHC Sensor', color='blue')
ax1.set_title('Sensor Readings')
ax1.set_xlabel('Time Index')
ax1.set_ylabel('Sensor Value')
ax1.legend()
ax1.grid(True)

# Subplot 2: Scatter plot
ax2.scatter(
    df['PT08.S1(CO)'], 
    df['PT08.S2(NMHC)'], 
    alpha=0.6, 
    color='green'
)
ax2.set_title('CO vs NMHC Sensors')
ax2.set_xlabel('CO Sensor')
ax2.set_ylabel('NMHC Sensor')
ax2.grid(True)

# Adjust layout and show
plt.tight_layout()
plt.show()

Seaborn

Seaborn, developed by Michael Waskom, is a Python library designed for generating compelling and informative statistical visualizations. Building upon matplotlib, it provides a more streamlined syntax and more appealing default chart aesthetics. Its seamless integration with pandas DataFrames makes it highly intuitive for creating charts from tabular data.

Key features include:

Built-in styles and color palettes: Charts are automatically rendered with a professional appearance, reducing the need for manual customization.
Automatic legends and labels: This feature significantly reduces the code required to produce readable charts.
Exploratory Data Analysis (EDA) Utility: Especially useful for quickly visualizing data patterns and relationships during EDA.
1. Includes functions for visualizing statistical distributions, such as `distplot()`, `histplot()`, `boxplot()`, and `violinplot()`.
2. Enables easy creation of correlation graphs using the `heatmap()` function, which visualizes correlation matrices as heatmaps.
The `pairplot()` function automatically generates a matrix of plots, illustrating relationships between all variable pairs in a dataset.

Best uses for Seaborn:

Admin dashboards vs end-user simple UI – quickly generate aesthetically pleasing, statistical charts for reports and presentations.
Customization with customer branding – ready-made color palettes and styles that can be easily customized.

Usage Example of Seaborn:

Seaborn’s `pairplot` offers comprehensive visualization with a single function call. It creates a matrix displaying KDE (Kernel Density Estimation) curves for each variable on the diagonal, scatter plots for variable pairs off-diagonal, and color-codes points by CO pollution levels (Low/Medium/High). This tool simplifies exploratory data analysis, quickly revealing relationships, pollutant correlations, temperature impacts, and pollution level clustering within datasets.

It was created using:

				
					import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Read the dataset
df = pd.read_csv('dataset.csv')

# Convert key columns to numeric
numeric_cols = ['CO(GT)', 'NOx(GT)', 'NO2(GT)', 'T', 'RH']
for col in numeric_cols:
    if col in df.columns:
        df[col] = pd.to_numeric(df[col], errors='coerce')

# Create pollution level categories for coloring
df['CO_Level'] = pd.cut(
    df['CO(GT)'], 
    bins=3, 
    labels=['Low', 'Medium', 'High']
)

# Seaborn's unique pairplot feature - shows all variable relationships at once
sns.pairplot(data=df[[
                 'CO(GT)',
                 'NOx(GT)', 
                 'NO2(GT)', 
                 'T', 
                 'RH', 
                 'CO_Level'
             ]], 
             hue='CO_Level', 
             diag_kind='kde',
             plot_kws={'alpha': 0.7})

plt.suptitle('Air Quality Variables Pairwise Relationships', y=1.02)
plt.show()

PyQtGraph

A Python library built on the Qt framework, is designed for interactive graphs and real-time data visualization. It prioritizes performance, using OpenGL for graphics acceleration to ensure smooth rendering of large datasets.

Key features include:

Diverse Chart Types: Supports line, point, bar, histograms, 3D charts, images, and heat maps.
User Interaction: Charts can be zoomed, moved, rotated, and modified in real-time with mouse and keyboard.
Qt Integration: Built-in Qt widgets allow easy integration into GUI applications made with PyQt or PySide.
Data Streaming: Ideal for real-time monitoring applications due to its support for continuous data flow.
Advanced Styling: Offers customization for colors, fonts, axes, legends, and other visual elements.
Image Analysis: Provides tools for displaying, manipulating, and analyzing 2D images with zoom and pan.
3D Visualizations: Enables the creation of 3D charts with rotation and scaling capabilities.
Low System Requirements: Efficiently runs on older hardware thanks to OpenGL optimizations.
Flexible Layout: Allows complex interfaces with multiple charts in one window.
Data Export: Charts can be saved in various graphic formats (PNG, SVG, PDF).

Best uses for PyQtGraph:

Real-time sensor dashboards – seamless data visualization with high measurement frequency.
Zoom in/out – native interaction support: zoom in, zoom out and pan the chart in real-time.

Usage Example of PyQtGraph:

This is a simple chart showing CO concentration. What sets it apart from others is its interactivity. This chart appears in the system window, where we can perform actions such as:

Mouse wheel zoom
Click and drag to pan
Right-click menu for plot options
Automatic rescaling

It was run using following code snippet:

				
					import pandas as pd
import pyqtgraph as pg
from pyqtgraph.Qt import QtCore
import numpy as np

# Read the dataset
df = pd.read_csv('dataset.csv')

# Convert date column to datetime
df['DT'] = pd.to_datetime(df['DT'])

# Convert string columns to numeric (replacing commas with dots for decimals)
numeric_cols = ['CO(GT)', 'C6H6(GT)', 'T', 'RH', 'AH']
for col in numeric_cols:
    if col in df.columns:
        df[col] = pd.to_numeric(df[col].astype(str).str.replace(',', '.'), errors='coerce')

# Create timestamp array for x-axis
timestamps = df['DT'].values.astype(np.int64) // 10**9  # Convert to seconds

# Create the plot window
app = pg.mkQApp("Air Quality Monitor")
win = pg.GraphicsLayoutWidget(show=True, title="Air Quality Sensor Data")
win.resize(1200, 800)

# Create multiple plots for different pollutants
colors = ['r', 'g', 'b', 'y', 'c', 'm']
pollutants = ['CO(GT)', 'NOx(GT)', 'NO2(GT)', 'C6H6(GT)']

# Main plot - Multiple pollutants on same axis
p1 = win.addPlot(title="Pollutant Levels Over Time", row=0, col=0, colspan=2)
p1.setLabel('left', 'Concentration')
p1.setLabel('bottom', 'Time')
p1.addLegend()

# Plot each pollutant with different colors
for i, pollutant in enumerate(pollutants):
    if pollutant in df.columns:
        y_data = df[pollutant].fillna(0).values
        p1.plot(timestamps, y_data, pen=colors[i % len(colors)], 
                name=pollutant, width=2)

# Temperature and Humidity subplot
win.nextRow()
p2 = win.addPlot(title="Temperature", row=1, col=0)
p2.setLabel('left', 'Temperature (°C)')
p2.setLabel('bottom', 'Time')
if 'T' in df.columns:
    p2.plot(timestamps, df['T'].fillna(0).values, pen='w', width=2)

p3 = win.addPlot(title="Relative Humidity", row=1, col=1)
p3.setLabel('left', 'RH (%)')
p3.setLabel('bottom', 'Time')
if 'RH' in df.columns:
    p3.plot(timestamps, df['RH'].fillna(0).values, pen='c', width=2)

# Scatter plot - correlation between two pollutants
win.nextRow()
p4 = win.addPlot(title="CO vs NOx Correlation", row=2, col=0, colspan=2)
p4.setLabel('left', 'NOx(GT)')
p4.setLabel('bottom', 'CO(GT)')
if 'CO(GT)' in df.columns and 'NOx(GT)' in df.columns:
    scatter = pg.ScatterPlotItem(df['CO(GT)'].fillna(0).values, 
                                 df['NOx(GT)'].fillna(0).values,
                                 size=5, pen=None, brush='y')
    p4.addItem(scatter)

# Show the plot
win.show()
app.exec_()

Plotly

Versatile and robust library for interactive data visualization, with APIs available in Python, R, JavaScript, and Julia. It enables users to create a wide array of interactive charts -from fundamental line and bar charts to intricate 3D visualizations, geographical maps, and financial charts that support zooming, panning, hovering for details, and data filtering.

The library offers two main interfaces: Plotly Graph Objects (plotly.graph_objects) for detailed, low-level control, and Plotly Express for rapid creation of common visualization types. Charts can be exported to various formats such as HTML, PNG, SVG, and PDF, and are easily embeddable in web applications and Jupyter notebooks.

Plotly provides extensive customization options, including control over colors, fonts, layouts, and animations, as well as the ability to add annotations and shapes. It seamlessly integrates with popular Python libraries like Pandas, NumPy, Scikit-learn, and Matplotlib, streamlining data analysis workflows.

A key feature of Plotly is its animation capability, which allows for the creation of dynamic charts that smoothly illustrate data evolution over time. Additionally, Plotly Chart Studio serves as an online platform for creating, editing, and sharing charts directly within a web browser.

Best uses for Plotly:

Interactive drill-down charts – clickable series, subset selection, “on-the-fly” filtering.
Mobile-friendly UIs – responsive HTML charts that work seamlessly on smartphones and tablets with touch support.
Admin Dashboards vs end-user simple UIs – from simple dashboards to full dashboards.
Customization with customer branding – themes and CSS styles can be customized with customer colors and logos.

Usage example of Plotly:

By using provided code snippet, it is possible to create an interactive scatter plot showing three major air pollutants over time:

CO (Carbon Monoxide) – displayed as red markers
NOx (Nitrogen Oxides) – displayed as orange markers
NO2 (Nitrogen Dioxide) – displayed as brown markers

Each data point represents a measurement at a specific date. Markers are semi-transparent to handle overlapping data points

				
					import pandas as pd
import plotly.graph_objects as go
import numpy as np

# Read the dataset
df = pd.read_csv('dataset.csv')

# Clean the data - replace -200 with NaN (missing data indicator)
df['CO(GT)'] = pd.to_numeric(df['CO(GT)'], errors='coerce').replace(-200.0, np.nan)
df['NOx(GT)'] = pd.to_numeric(df['NOx(GT)'], errors='coerce').replace(-200.0, np.nan)
df['NO2(GT)'] = pd.to_numeric(df['NO2(GT)'], errors='coerce').replace(-200.0, np.nan)

# Create the plot with scatter markers
fig = go.Figure()

# Add scatter traces for each pollutant
fig.add_trace(go.Scatter(x=df['DT'], y=df['CO(GT)'], 
                         mode='markers', name='CO', 
                         marker=dict(color='red', size=8, opacity=0.7)))

fig.add_trace(go.Scatter(x=df['DT'], y=df['NOx(GT)'], 
                         mode='markers', name='NOx', 
                         marker=dict(color='orange', size=8, opacity=0.7)))

fig.add_trace(go.Scatter(x=df['DT'], y=df['NO2(GT)'], 
                         mode='markers', name='NO2', 
                         marker=dict(color='brown', size=8, opacity=0.7)))

# Update layout
fig.update_layout(
    title='Air Pollutant Concentrations Over Time',
    xaxis_title='Date',
    yaxis_title='Concentration (µg/m³)',
    hovermode='x unified',
    showlegend=True,
    width=900,
    height=500
)

# Show the plot
fig.show()

IoT data visualization libraries technical comparison

Basic information about libraries:

Feature	Matplotlib	Seaborn	PyQtGraph	Plotly
License	PSF License (BSD-style)	BSD 3-Clause	MIT License	MIT License
First Release	2003	2012	2010	2012
Primary Language	Python/C++	Python	Python/C	Python/JavaScript
Backend Architecture	Multiple backends (Agg, Qt, Tk, etc.)	Built on matplotlib	Qt-based (PyQt/PySide)	Web-based (JavaScript/D3.js)
Installation Size	~37 MB	~1 MB (+ matplotlib deps)	~15 MB	~28 MB

Core dependencies:

Library	Core Dependencies	Optional Dependencies
Matplotlib	numpy, pyparsing, python-dateutil, cycler, kiwisolver	pillow, ffmpeg, ghostscript, latex
Seaborn	matplotlib, numpy, pandas, scipy	statsmodels
PyQtGraph	numpy, PyQt5/PyQt6 or PySide2/PySide6	scipy, pyopengl, hdf5, colorcet
Plotly	tenacity	pandas, numpy, scipy, statsmodels, scikit-image, orjson, psutil

Rendering and performance:

Feature	Matplotlib	Seaborn	PyQtGraph	Plotly
Rendering Engine	Multiple (Cairo, AGG, etc.)	Matplotlib backends	OpenGL/QPainter	WebGL/SVG/Canvas
Real-time Capability	Limited	No	Excellent	Good
Large Dataset Handling	Poor (>10k points)	Poor (>10k points)	Excellent (>1M points)	Good (>100k points)
Memory Efficiency	Moderate	Moderate	High	Moderate
GPU Acceleration	No	No	Yes (OpenGL)	Yes (WebGL)
Interactive Performance	Slow	Slow	Fast (60+ FPS)	Good

Plot types and capabilities:

Plot Type	Matplotlib	Seaborn	PyQtGraph	Plotly
Line Plots	Full support	Enhanced styling	Optimized for speed	Full support
Scatter Plots	Full support	Enhanced + regression	High-performance	Full support
Histograms	Full support	Enhanced + distributions	Basic	Full support
Heatmaps	Basic	Advanced (correlation, etc.)	Basic	Full support
3D Plots	Basic support	Limited	Excellent	Full support
Statistical Plots	Basic	Specialized (violin, box, etc.)	Limited	Good
Time Series	Good	Good	Excellent	Excellent
Animations	Good	Limited	Excellent	Good
Geographic/Maps	Plugin required	No	No	Built-in

Customization and styling:

Feature	Matplotlib	Seaborn	PyQtGraph	Plotly
Theme System	rcParams + styles	Built-in themes	Limited themes	Extensive themes
Color Palettes	Basic + custom	Advanced palettes	Basic + custom	Advanced palettes
Font Control	Full control	Inherited from matplotlib	Limited	Good control
Layout Control	Subplot system	FacetGrid system	Layout widgets	Subplot system
Custom Widgets	Limited	No	Extensive	Limited
CSS Styling	No	No	Limited	Yes
Programmatic Control	Full API access	Limited to seaborn features	Full Qt integration	Full API access

Interactivity features:

Feature	Matplotlib	Seaborn	PyQtGraph	Plotly
Zoom/Pan	Basic	Basic	Advanced	Advanced
Selection Tools	Limited	No	Advanced	Good
Hover Information	Plugin required	No	Built-in	Built-in
Click Events	Basic	No	Advanced	Advanced
Real-time Updates	Difficult	No	Excellent	Good
Cross-filtering	No	No	Custom implementation	Built-in
Brushing/Linking	No	No	Advanced	Good

Output formats:

Format	Matplotlib	Seaborn	PyQtGraph	Plotly
Vector (SVG/PDF/EPS)	Yes	Yes (via matplotlib)	Limited	Yes
Raster (PNG/JPG)	Yes	Yes (via matplotlib)	Yes	Yes
Interactive HTML	Limited (mpld3 plugin)	No	No	Yes
Static HTML	No	No	No	Yes
LaTeX Integration	Excellent	Good	No	Limited
Print Quality	Excellent	Excellent	Good	Good

What's the best desktop library for IoT data visualization?

Desktop libraries for IoT sensor data visualization are often the best choice when performance, security, and customization matter. The right option depends on project requirements and deployment context.

Matplotlib – suited for low-power environments and formal company reports. It requires few dependencies, offers precise control over visuals, and works well for branded PDF exports or small devices.

Seaborn – ideal for statistical analysis. It helps uncover patterns in IoT data quickly with strong defaults and built-in analytical functions.

PyQtGraph – recommended for real-time monitoring and interactive dashboards. With OpenGL support, it handles millions of data points smoothly, making it reliable for factories, smart buildings, or environmental networks.

Plotly – best for cross-device use and touch interfaces. Its HTML output makes dashboards easy to share, embed, and adapt to different screens, while theme customization supports client-facing apps.

There is no single “best” library. The choice should follow the needs of each IoT project—whether reporting, analysis, monitoring, or interactive dashboards.

Write to us — we will analyze your project, show you the differences, and choose the best one for You.