Serial Studio
Serial Studio turns data from your hardware into a live dashboard.
Connect an Arduino, ESP32, STM32, Raspberry Pi, Teensy, or anything else that speaks serial, Bluetooth, a network protocol, or an industrial bus. Describe the data format once in a project file. Serial Studio draws the plots, gauges, maps, and 3D views around it. Send commands back with buttons, sliders, and knobs. Record a session, replay it, export it as a PDF.
It replaces the stack of separate tools this work usually requires: a serial monitor and serial plotter for Arduino and ESP32 development, a real-time telemetry dashboard, a data logger that records to CSV or SQLite, and a PLC, Modbus, CAN bus, OPC UA, or MQTT monitor for industrial and IoT systems.
Runs on Windows, macOS, Linux, and Raspberry Pi.
Use cases shows how people apply it across 18 fields, from rocketry and drones to industrial automation. Comparison sets it against the Arduino IDE Serial Plotter, Processing, MATLAB, LabVIEW, and Grafana.
What you can do with it
Connect to a device. Serial/UART, Bluetooth LE, and network sockets (TCP, UDP, WebSocket, HTTP) in the GPL build. MQTT, Modbus TCP/RTU, CAN Bus, OPC UA, Siemens S7comm, EtherNet/IP, IEC 60870-5-104, audio input, raw USB (libusb), HID (hidapi), and Process I/O are Pro. Multiple devices in one project is also Pro.
Read PLCs without a gateway (Pro). OPC UA covers modern controllers: browse the address space, tick the tags you want, and the project generates itself. Three direct drivers cover the rest of the plant floor, no KEPServer-class gateway in between. S7comm polls absolute addresses (DB5.DBD20:REAL, MW10) on Siemens S7-300, S7-400, S7-1200, and S7-1500 controllers. EtherNet/IP polls symbolic tag names on Allen-Bradley ControlLogix, CompactLogix, MicroLogix, Micro800, SLC 500, and PLC-5, plus Omron NJ/NX. IEC 60870-5-104 interrogates RTUs and substation gateways and streams their spontaneous reports, generating the project from the station's own database. All three are read-only clients: connecting Serial Studio to a running machine cannot change its state. On the MQTT side, Sparkplug B works in both directions — subscribe as a host application and generate a project from the birth certificates, or publish your dashboard as an edge node.
Visualize data. 17 widgets in the GPL build: line plots, gauges, bar charts, meters, GPS maps, FFT spectrum, accelerometer, gyroscope, compass, data grids, LED panels, terminal, multi-channel plots, web view, bar panel, plus a Clock and Stopwatch utility widget pair. Bar, Gauge, Compass, and Meter each render as a two-page swipe view (page 0 is the analog face, page 1 is a large digital readout), so a single tile shows both the trend at a glance and the exact value. Pro adds 3D Plot, Waterfall (spectrogram), Image View (live camera), the Canvas widget, and output widgets (buttons, sliders, knobs, an Output Panel, and a Notification Log). Canvas is a JavaScript paint(ctx, w, h) callback with a Canvas2D-style API and 18 templates: oscilloscope, polar plot, artificial horizon, audio VU, dial gauge, heatmap, sparklines, vector field, XY scope, and others.
Build dashboards. The Project Editor defines groups, datasets, and widgets through forms. Or skip the project file: print CSV from your device and Quick Plot draws it. Custom workspaces (Pro) split big projects into tabs with a searchable taskbar.
Parse and transform data. Frame parsers come in three flavors: Built-In templates (compiled C++ parsers you configure through a form, no code, the default for new projects), JavaScript, and Lua (LuaJIT 2.1, 5.1 syntax with compatibility shims). 28 script templates cover MAVLink, NMEA 0183/2000, UBX, SiRF, RTCM, MessagePack, TLV, COBS, SLIP, JSON, XML, YAML, INI, Modbus, and others. Per-dataset transforms (EMA, scaling, calibration, unit conversion) run every frame as short JS or Lua snippets. Variables act as a shared bus so transforms can derive computed datasets from each other. Transforms and Variables are Pro.
Send commands back (Pro). Buttons, toggles, sliders, knobs, text fields, and freeform output panels run JS templates that emit GCode, SCPI, Modbus, NMEA, CAN, or whatever your device speaks. Actions run on demand or on a timer.
Record and replay. CSV export in the GPL build. MDF4 import/export, session recording (frames and raw bytes) into SQLite, PDF session reports, and XMODEM/YMODEM/ZMODEM file transfer are Pro. If the data belongs in your existing time-series stack instead of a local file, a live sink streams every frame into InfluxDB 2.x as line protocol (Pro).
Automate it. A TCP API on port 7777 with 360+ commands. A gRPC server on port 8888 mirrors the same command set with protobuf and live frame streaming. An MCP server wraps the same surface for Claude Desktop or any other MCP host.
AI Assistant for project editing (Pro). A bring-your-own-key chat panel that edits the project. Eight providers: Anthropic, OpenAI, Google Gemini, DeepSeek, Groq, Mistral, OpenRouter, and local OpenAI-compatible endpoints (Ollama, llama.cpp, LM Studio, vLLM) for offline use. Mutating actions show an Approve/Deny card first. See the AI Assistant docs.
Vendor-document importers (Pro). Feed the Modbus register-map importer a vendor CSV/XML/JSON and get a project. DBC import decodes CAN signals from the standard automotive files, extended multiplexing included, and the CAN driver reassembles multi-packet J1939 and ISO-TP transfers so long PGNs decode the same way 8-byte frames do. For OPC UA servers there is nothing to import: browse the server's address space, tick the tags you want, and Serial Studio generates the project from them.
Download
Serial Studio is available as source code and as official precompiled binaries for Windows, macOS, and Linux.
Windows
Requires the Microsoft Visual C++ Redistributable (x64). On first launch Windows may warn about an unknown developer. Click "More Info", then "Run Anyway" to continue.
macOS
Distributed as a universal DMG. Open the DMG and drag Serial Studio into Applications. You can also install it via Homebrew:
brew install --cask serial-studio
The Homebrew cask is community-maintained. It's available, but not officially tested by me.
Linux
The recommended way to install on Linux is via the official AppImage. Download it from the latest release, then make it executable and run it (replace <version> with the version you downloaded):
chmod +x Serial-Studio-Pro-<version>-Linux-x64.AppImage
./Serial-Studio-Pro-<version>-Linux-x64.AppImage
For better desktop integration (menu entries, icons, updates), use AppImageLauncher.
Flatpak (Flathub)
Serial Studio is on Flathub. That version gets regular updates and tends to work better on ARM64. On some desktop environments, mostly Wayland, you may see small visual glitches like missing window shadows.
Raspberry Pi / ARM64
An ARM64 AppImage is available for Raspberry Pi and similar boards. It runs well on Raspberry Pi 4/5 and on integrated graphics. Requirements:
- A 64-bit Linux distro (Raspberry Pi OS 64-bit, Ubuntu, Debian, etc.)
All Linux packages (AppImage, DEB, RPM, x64 and ARM64) bundle their own glibc, so they run on any distribution from the Debian 10 / RHEL 8 generation onward (releases up to 4.0.3 required a newer host glibc); no minimum glibc version is required on the host.
Features
How it works
- Project file mode (recommended): Define your data format and dashboard in the Project Editor, using structured forms for groups, datasets, and widgets.
- Quick plot mode: Drop in comma-separated values from Arduino and get an instant plot.
- Console only mode: Use Serial Studio as a plain terminal without any dashboard.
At a glance
- Protocols: Serial/UART, Bluetooth LE, and network sockets (TCP, UDP, WebSocket, HTTP) in the GPL build. MQTT, Modbus TCP/RTU, CAN Bus, OPC UA, Siemens S7comm, EtherNet/IP, IEC 60870-5-104, Audio, raw USB (libusb), HID (hidapi), and Process I/O are Pro.
- PLC drivers (Pro): S7comm for Siemens S7-300/400/1200/1500, EtherNet/IP for Allen-Bradley and Omron NJ/NX, IEC 60870-5-104 for RTUs and substation gateways. Read-only clients, no OPC UA gateway required.
- Sparkplug B (Pro): subscribe to a broker as a host application and generate the project from birth certificates, or publish the dashboard as an edge node.
- Visualization: 23 widgets, including line plots, gauges, bar charts, meters, GPS maps, FFT, waterfall (spectrogram), accelerometer, gyroscope, compass, data grids, 3D views, live camera feed, plus Clock and Stopwatch utility widgets (some Pro). Bar, Gauge, Compass, and Meter each include a swipeable digital readout page alongside the analog face.
- Canvas widget (Pro): scriptable Canvas2D-style canvas driven by a JS
paint(ctx, w, h) callback. Watchdog-protected QJSEngine, persistent script state across frames, 18 templates (oscilloscope, polar plot, artificial horizon, audio VU meter, dial gauge, heatmap, LED matrix, sparklines, vector field, XY scope, and more).
- Output widgets: buttons, toggles, sliders, knobs, text fields, and freeform panels, with JS templates for GCode, SCPI, Modbus, NMEA, CAN, and more (Pro).
- Custom parsing: Built-In template, JavaScript, or Lua (LuaJIT 2.1, 5.1 syntax with compatibility shims) frame parsers, plus 28 script templates (MAVLink, NMEA 0183/2000, UBX, SiRF, RTCM, MessagePack, TLV, COBS, SLIP, JSON, XML, YAML, INI, Modbus, and more).
- Per-dataset transforms: short JS or Lua snippets to filter, scale, calibrate, or derive values every frame (Pro).
- Variables: shared bus for system datasets, user-defined constants and computed variables, and computed datasets built entirely from transforms (Pro).
- Custom workspaces: split large projects into focused dashboard tabs, with a taskbar search (Pro).
- CSV export: every frame, ready for Excel, Python, MATLAB, or R.
- MDF4: read and write MDF4/MF4 for CAN Bus, LIN, FlexRay, and analog (Pro).
- Historian: record frames and raw bytes into SQLite, then browse, tag, export, and replay them (Pro).
- Session reports: export a session as a styled HTML or PDF with interactive Chart.js plots (Pro).
- File transfer: XMODEM, YMODEM, and ZMODEM with CRC and crash recovery (Pro).
Quick start
A first connection takes about five minutes.
1. Download and install
- Grab the latest release for your platform (see Download).
- Windows: run the installer. Allow "Unknown developer" if prompted.
- macOS: drag to Applications, then right-click and choose Open the first time.
- Linux:
chmod +x the AppImage and run it.
2. Connect your device
- Launch Serial Studio.
- Pick your serial port and baud rate (9600 and 115200 are common).
- Click Connect.
3. Visualize
- Quick plot mode: send comma-separated values and watch them plot live.
- Project mode: build a custom dashboard in the Project Editor, complete with gauges, maps, and more.
- Examples: browse
/examples for Arduino sketches, ESP32 code, and Python scripts.
Arduino example
void setup() {
Serial.begin(9600);
}
void loop() {
int temperature = analogRead(A0);
int humidity = analogRead(A1);
Serial.print(temperature);
Serial.print(",");
Serial.println(humidity);
delay(100);
}
Upload, connect Serial Studio, enable Quick Plot, and you're done.
First time using it? Start with the getting started guide. The help center covers troubleshooting and common questions.
Documentation
Official docs
- Help center: FAQs, use cases, comparisons, troubleshooting.
- Getting started: first connection, the three operation modes, and common problems.
- Use cases: 18 fields where Serial Studio is used, with the hardware and data rates involved.
- Comparison: how it differs from the Arduino Serial Plotter, Processing, MATLAB, LabVIEW, and Grafana.
- Pro vs Free: the full feature matrix for both editions.
- Local help docs: Markdown source for the in-app help center.
- AI agent guide: for ChatGPT, Claude, and other assistants.
- API reference: full TCP API and automation docs.
- gRPC server: protobuf API and streaming reference.
- Examples: Arduino, ESP32, Python code with sample projects.
Key topics
- Installation for Windows, macOS, Linux, and Raspberry Pi.
- Quick start: connect an Arduino or ESP32 and visualize data in five minutes.
- Dashboard creation: build layouts in the Project Editor and split them into workspaces.
- Protocol support: Serial/UART, Bluetooth LE, MQTT (with Sparkplug B), Modbus TCP/RTU, CAN Bus, OPC UA, Siemens S7comm, EtherNet/IP, IEC 60870-5-104, TCP/UDP/WebSocket/HTTP, Audio, raw USB, HID, Process I/O.
- Frame parsing: handle binary protocols, checksums, and custom formats with Built-In templates, JavaScript, or Lua (LuaJIT 2.1, 5.1 syntax with compatibility shims).
- Per-dataset transforms: EMA filters, scaling, calibration, and computed datasets via Variables.
- Output widgets: send commands back with buttons, sliders, knobs, toggles, and output panels (Pro).
- Canvas widget: write your own dashboard widget in JavaScript when the built-ins don't fit (Pro).
- File transfer: XMODEM, YMODEM, and ZMODEM over the active connection (Pro).
- CSV export and playback: log sensor data and replay it.
- MDF4 playback and export: CAN Bus, LIN, FlexRay, and analog (Pro).
- Historian: record, tag, export, and replay full sessions from SQLite (Pro).
- Session reports: export HTML or PDF reports with interactive Chart.js plots (Pro).
- TCP API: 360+ commands for programmatic control (see API Client).
Building Serial Studio
Requirements
Minimum:
- Qt 6.9 or later (6.11.2 recommended). Required modules: QtCore, QtGui, QtWidgets, QtQml, QtQuick, QtQuickControls2, QtGraphs, QtSvg, QtSql, QtSerialPort, QtBluetooth, QtCore5Compat, and Qt LinguistTools at build time.
- C++20 compiler: GCC 10+ (Linux), Clang 12+ (macOS), or MSVC 2019+ (Windows).
- CMake 3.20 or later.
- Platform toolchain (see Platform specifics).
Platform specifics
Linux
sudo apt install libgl1-mesa-dev build-essential
macOS
xcode-select --install
brew install qt@6
Windows
Visual Studio 2019 or later with the C++ workload, and Qt from the official installer.
Build instructions
All C/C++ dependencies (zlib, expat, OpenSSL, KissFFT, and so on) are vendored in lib/ or fetched automatically via CMake's FetchContent. No package manager is needed.
cmake -B build -DPRODUCTION_OPTIMIZATION=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j$(nproc)
On Windows the default generator is Visual Studio, which is multi-config: it ignores CMAKE_BUILD_TYPE and builds Debug unless you pass --config Release to the build step (as shown above). Skipping it builds the Debug config, which mixes MSVC's /RTC1 runtime checks with the production /O2 flags and fails with '/O2' and '/RTC1' command-line options are incompatible. Alternatively, configure with the single-config Ninja generator (cmake -B build -G Ninja ...), which honors CMAKE_BUILD_TYPE.
You can also open CMakeLists.txt in Qt Creator or any CMake-aware IDE without extra setup.
The default build is the GPLv3 edition. It includes the core: UART, network (TCP/UDP/WebSocket/HTTP), and BLE drivers, the Project Editor, Quick Plot and Console modes, the standard widgets (line plot, gauge, bar, GPS, FFT, accelerometer, gyroscope, compass, data grid, LED panel, terminal, multi-plot), Built-In, JavaScript, and Lua frame parsers, CSV export, and the local TCP/MCP API.
Pro-only modules are not built into the GPL edition: MQTT (Sparkplug B included), Modbus, CAN Bus, OPC UA, Siemens S7comm, EtherNet/IP, IEC 60870-5-104, the InfluxDB sink, Audio, USB, HID, Process I/O, multi-source projects, the 3D Plot, Waterfall, Image View, and Canvas widgets, the output widgets, MDF4 import/export, the Historian, session reports, XMODEM/YMODEM/ZMODEM file transfer, the Modbus register-map and CAN DBC importers, and the AI Assistant. Some of those depend on proprietary Qt modules (Modbus, CAN Bus, MQTT, OPC UA); others are commercial-licensed code in this repository. Per-dataset transforms, Variables, and custom workspaces are Pro features too: the GPL edition cannot create or edit them, and a project that contains a transform or a Variables table needs Pro to connect (removing them is free). The notification log is also Pro. See Pro vs Free Features for the full matrix.
If you are a Pro user or have a commercial license, contact the maintainer for build instructions and activation details.
Support the project
Serial Studio is developed and maintained by Alex Spataru. It is open source and community-driven, with commercial options for users who need advanced features or a business-friendly license.
If Serial Studio is useful to you, here are a few ways to support it:
- Donate via PayPal: keeps the project active.
- Buy a commercial license: unlocks Pro features and priority support. GPL builds compiled from source are governed by the GPLv3 alone, with no additional restrictions.
- Become an affiliate: a good fit for content creators who want to earn a commission by referring new customers.
Commercial licenses directly fund development, bug fixes, and new features.
Licensing
Serial Studio uses a dual-license model that separates open source usage from commercial distribution:
Source files are individually marked with SPDX headers, either GPL-3.0-or-later, LicenseRef-SerialStudio-Commercial, or both. This lets developers build and distribute GPL-compliant versions while keeping commercial features protected.
Picking the right version
The official binary runs without a license. Its free features work with no time limit for personal, educational, and open-source use, and the first Pro feature you use offers a 14-day Pro trial; when the trial ends, Pro features lock and the free features keep working. Commercial use of the official binary requires a Pro license. The table below shows licensing, feature access, and obligations for each edition.
| Feature / use case | GPL build (compiled from source) | Official binary (no license) | Official binary (Pro license) |
|---|
| Free features | ✅ Included | ✅ Included, no time limit | ✅ Included |
| Pro features | ❌ Not included | 14-day trial, then locked | ✅ Included |
| Commercial use | ✅ Permitted under GPLv3 | ❌ Requires a Pro license | ✅ Fully licensed |
| Official support | ❌ Community only | ❌ Community only | ✅ Priority support |
| Usage restrictions | Must comply with GPL and Qt terms | Bound by the EULA, no redistribution | Bound by commercial license terms |
| Precompiled binary | ❌ Must build from source | ✅ Provided | ✅ Provided |
| Qt licensing | Requires GPL-compatible Qt | Qt licensing covered by vendor | Qt licensing covered by vendor |
| Activation system | ❌ Not applicable | None; the trial registers the machine | ✅ Requires a valid license key |
| Business use | ✅ Permitted (no Pro features) | ❌ Requires a Pro license | ✅ Fully allowed |
| Best for | OSS devs, students, contributors | Hobbyists, personal evaluation | Businesses, teams, commercial products |
The GPL build carries the full GPLv3 grant: use for any purpose, commercial use included, with no restrictions beyond the GPL's own terms. It excludes the Pro modules. Pro features and official binaries are proprietary: the official binaries are governed by the EULA, and using Pro features beyond the 14-day trial requires a commercial license. A file's SPDX header states its license; files marked commercial-only carry no GPL rights.
Contributing
Contributions are welcome: bug fixes, new features, or doc improvements. CONTRIBUTING.md has the full guide.
Before contributing:
- Check existing issues and pull requests.
- Review CLAUDE.md for code style.
- Contributions to both GPL-licensed code and the commercial (Pro) modules are welcome. Pro contributions are accepted under the Contributor License Agreement in CONTRIBUTING.md.
Code style:
- Follow the project's clang-format config (LLVM base style).
- Use meaningful names.
- Avoid inline end-of-line comments (see doc/claude/code-style.md).
- Add Doxygen comments for new public APIs.
Submitting changes:
- Fork the repository.
- Create a feature branch (
git checkout -b feature/amazing-feature).
- Commit with descriptive messages.
- Push to your fork and open a pull request.
- Make sure CI passes.
For larger changes, open an issue first so we can talk about the approach.
