doc/help/FAQ.md
Answers to common questions about Serial Studio, from installation to advanced use.
Serial Studio is an open source tool for visualizing data from devices in real time. You can monitor sensors, debug hardware, and build custom dashboards without writing code.
It works with any device that sends data via serial port, Bluetooth LE, MQTT, Modbus TCP/RTU, CAN Bus, raw USB, HID, audio input, the output of another program (Process I/O), or TCP/UDP sockets.
The core is open source, with two flavors:
Pro features are proprietary. They're not open source. See the License Agreement and Pro vs GPL for details.
The Arduino Serial Plotter is good for quick debugging, but it only works with serial ports and basic plots.
Serial Studio adds:
See Pro vs Free for a detailed comparison.
Official binaries: yes, with a Pro license. Commercial use covers business use, revenue-generating projects, client-facing systems, and grant- or privately-funded research.
GPL build: no. Serial Studio's license terms reserve commercial use for Pro license holders, even when you build from source with GPL modules only. GPL builds are intended for personal, educational, and open source projects, and they don't include Pro features like MQTT, Modbus, CAN Bus, or 3D visualization.
See the License Agreement for the full dual-licensing details.
Spataru, A. (2025). Serial Studio: Open-Source Telemetry Dashboard and Data Visualization Tool.
GitHub. https://github.com/Serial-Studio/Serial-Studio
Use the DOI if there is one (check the GitHub repository).
SerialStudio-Pro-3.x.x-Windows-x64.exe from GitHub releases.Option 1: official DMG (recommended).
SerialStudio-Pro-3.x.x-macOS-Universal.dmg from GitHub releases.Option 2: Homebrew (community-maintained).
brew install --cask serial-studio
Recommended: AppImage.
# Download from GitHub releases
chmod +x SerialStudio-Pro-3.x.x-Linux-x64.AppImage
./SerialStudio-Pro-3.x.x-Linux-x64.AppImage
If it fails to launch, install libfuse2:
sudo apt install libfuse2
Alternative: Flatpak (GPLv3).
flatpak install flathub com.serial_studio.Serial-Studio
flatpak run com.serial_studio.Serial-Studio
You need permission to access serial devices. Add your user to the dialout group:
sudo usermod -a -G dialout $USER
Then log out and back in for the change to take effect.
Prerequisites:
Linux build:
sudo apt install libgl1-mesa-dev build-essential
mkdir build && cd build
cmake ../ -DPRODUCTION_OPTIMIZATION=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . -j$(nproc)
For macOS and Windows, see the build instructions in the project repository.
If you don't see your device, check drivers (FTDI, CH340, CP2102) and permissions (on Linux, the dialout group).
Yes (Pro). Multi-device projects let you define several data sources in a single project file, each with its own protocol, connection settings, and frame detection. For example, all at the same time you can connect:
All devices feed into the same dashboard. Each source's data is routed to its own groups and widgets. CSV and MDF4 export captures every source in one file.
To set this up, open the Project Editor and add sources under the "Sources" section. Each source defines a bus type, connection parameters, and frame parsing rules.
Pro only.
mqtt://broker.hivemq.com:1883).sensors/temperature).Your devices should publish to the MQTT topic, and Serial Studio will visualize the data in real time.
Pro only. Both Modbus TCP and Modbus RTU are supported.
Modbus TCP:
192.168.1.100:502).Modbus RTU:
See the Modbus PLC Simulator example in /examples for a full demo.
Pro only.
See the CAN Bus Example in /examples for step-by-step instructions.
Pro only. MDF4 (Measurement Data Format 4) is common in automotive and industrial settings for recording CAN Bus, LIN, FlexRay, and analog sensor data.
Supported channels:
Use cases:
Pro only.
Benefits of MDF4 export:
Supported sources for MDF4 export:
192.168.1.100:8080).Example: a Python script sending UDP to Serial Studio:
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
data = f"{temperature},{humidity}\n"
sock.sendto(data.encode(), ("127.0.0.1", 8080))
Serial Studio works in three modes:
1. Console Only mode (diagnostic).
2. Quick Plot mode (easiest).
23.5,67.2,1013.25\n.3. Project File mode (recommended).
.ssproj project file with your dashboard layout in the Project Editor.See Operation Modes and Project Editor for more.
Method 1: Project Editor (easy).
.ssproj).Method 2: edit JSON by hand. Not recommended unless you're generating projects with scripts.
Free (GPL + Pro):
Pro only:
CSV format:
Elapsed (s),Group/Dataset 1,Group/Dataset 2,...
0.010000000,...
0.020000000,...
The first column is elapsed seconds with 9-decimal resolution. With multiple sources, the value columns are named Source/Group/Dataset.
Yes. Click Preferences → Theme and pick one.
Use a Dataset Value Transform. Select any dataset in the Project Editor, click the Transform button in the toolbar, and write a transform(value) function:
function transform(value)
return value * 0.01 + 273.15
end
The transform runs on every incoming frame and replaces the raw value everywhere: dashboard, plots, CSV export, and API. Built-in templates cover common operations like linear calibration, moving average, and unit conversion.
See Dataset Value Transforms for the full guide.
Windows:
macOS:
/dev/tty.usbserial-* or /dev/tty.usbmodem-*.Linux:
dialout: sudo usermod -a -G dialout $USER, then log out and back in./dev/ttyUSB* or /dev/ttyACM*.ls -l /dev/ttyUSB0.Baud rate. This is the most common cause. Make sure Serial Studio's baud rate matches the device (9600 or 115200 are common).
Data bits, parity, stop bits. Usually 8N1 (8 data bits, no parity, 1 stop bit). Change it in Serial Studio's settings if your device uses something else.
Frame delimiters. Serial Studio expects newline (\n) by default. If your device uses something different (\r\n, a semicolon, a custom byte), change the Frame Detection settings for the source in the Project Editor.
Quick Plot mode:
val1,val2,val3\n.\n) or a carriage return (\r).Project File mode:
Use a frame parser. Parsers can be written in JavaScript or Lua, or configured (not coded) as a Built-In template; see Frame Parser Scripting. JavaScript example:
function parse(frame) {
// frame is a string (text frames) or an array of byte values (binary frames)
// Return an array of values (the default parser returns frame.split(','))
let byte1 = frame[0];
let byte2 = frame[1];
let value = (byte1 << 8) | byte2;
return [value.toString()];
}
See the examples folder for sample parsers.
Bug report. If crashes persist, open a GitHub issue with:
Error: cannot open shared object file.
Install the missing library:
sudo apt install libfuse2
Error: glibc version too old.
The ARM64 AppImage needs Ubuntu 24.04+ (glibc 2.38+). Upgrade the OS or use the Flatpak version.
| Feature | GPL (open source) | Pro (proprietary) |
|---|---|---|
| Serial, BLE, TCP/UDP | ✅ | ✅ |
| MQTT | ❌ | ✅ |
| Modbus TCP/RTU | ❌ | ✅ |
| CAN Bus | ❌ | ✅ |
| Audio input | ❌ | ✅ |
| Basic plots, gauges, maps | ✅ | ✅ |
| XY plots | ❌ | ✅ |
| 3D visualization | ❌ | ✅ |
| FFT spectrum analyzer | ✅ | ✅ |
| Waterfall (spectrogram) | ❌ | ✅ |
| Painter (scriptable widget) | ❌ | ✅ |
| Output (control) widgets | ❌ | ✅ |
| Image View (camera/image stream) | ❌ | ✅ |
| Raw USB (libusb) | ❌ | ✅ |
| HID devices (hidapi) | ❌ | ✅ |
| Process I/O | ❌ | ✅ |
| Multi-device projects | ❌ | ✅ |
| CSV export and playback | ✅ | ✅ |
| MDF4 playback and export | ❌ | ✅ |
| Session Database (SQLite) | ❌ | ✅ |
| File transfer (X/Y/ZMODEM) | ❌ | ✅ |
| DBC file import (CAN) | ❌ | ✅ |
| Commercial use | ❌ Non-commercial only | ✅ |
| Priority support | ❌ | ✅ |
| Source availability | ✅ Open source | ⚠️ Visible but proprietary |
Check current pricing at serial-studio.com. Pro is sold as monthly, yearly, or lifetime licenses, each in three seat tiers:
Monthly and yearly plans renew until cancelled; the lifetime plan is a one-time perpetual purchase. The official binary includes a 14-day free trial.
Yes. Download the official binary and you get a 14-day trial with all Pro features enabled.
After 14 days:
Email [email protected] with:
Educational discounts are considered case by case.
If you have a Pro license, yes, you can use all features in your open source work.
That said, Pro features are proprietary even though their source code is visible in the repo. If you ship your project under GPL and your users build Serial Studio from source, they won't get Pro features (MQTT, Modbus, CAN Bus, 3D, and so on) unless they buy licenses.
See the License Agreement for the dual-licensing details.
Arduino quick start:
void setup() {
Serial.begin(9600);
}
void loop() {
int sensor1 = analogRead(A0);
int sensor2 = analogRead(A1);
Serial.print(sensor1);
Serial.print(",");
Serial.println(sensor2);
delay(100);
}
ESP32 BLE UART example:
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
BLECharacteristic *pCharacteristic;
// Nordic UART Service UUID
#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
void setup() {
BLEDevice::init("ESP32-Sensor");
BLEServer *pServer = BLEDevice::createServer();
BLEService *pService = pServer->createService(SERVICE_UUID);
pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID_TX,
BLECharacteristic::PROPERTY_NOTIFY
);
pCharacteristic->addDescriptor(new BLE2902());
pService->start();
pServer->getAdvertising()->start();
}
void loop() {
float temp = readTemperature();
String data = String(temp) + "\n";
pCharacteristic->setValue(data.c_str());
pCharacteristic->notify();
delay(1000);
}
Connect via the Serial Studio BLE interface.
Python over USB serial:
import serial
import time
ser = serial.Serial('/dev/ttyUSB0', 9600)
while True:
data = f"{temperature},{humidity}\n"
ser.write(data.encode())
time.sleep(1)
Python TCP server:
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("0.0.0.0", 8080))
sock.listen(1)
conn, addr = sock.accept()
while True:
data = f"{temperature},{humidity}\n"
conn.send(data.encode())
time.sleep(1)
Arduino CRC16 example:
uint16_t crc16(const char* data, int length) {
uint16_t crc = 0xFFFF;
for (int i = 0; i < length; i++) {
crc ^= data[i];
for (int j = 0; j < 8; j++) {
if (crc & 0x0001) crc = (crc >> 1) ^ 0xA001;
else crc = crc >> 1;
}
}
return crc;
}
void loop() {
char buffer[32];
snprintf(buffer, sizeof(buffer), "%d,%d\n", sensor1, sensor2);
uint16_t checksum = crc16(buffer, strlen(buffer));
Serial.print(buffer);
Serial.println(checksum);
delay(100);
}
In Serial Studio, use a JavaScript frame parser to validate the checksum and extract the data.
Yes. The Console panel has a send line: type text (or hex), pick a line ending, and Serial Studio writes it back to the connected device. You can also append a checksum to the outgoing bytes.
Other options:
setup() and loop() functions that runs in the background, so you can send commands on a timer or in response to incoming data, and drive the whole session from code. It uses the same scripting API as the frame parser.Yes. Serial Studio accepts command-line options, including a --headless flag that runs without a GUI (server mode) and --api-server to expose the API server on startup. You can pass a project file, a connection (UART, TCP, UDP, Modbus, CAN Bus), and export options (CSV, MDF4) from the command line. For CI/CD:
Use either approach in CI/CD for hardware-in-the-loop testing.
See README.md - Contributing for guidelines.
Quick start:
Non-code contributions:
Open a GitHub issue with:
Yes. Serial Studio accepts command-line options. Run it with --help to list them, or see the Command-Line Interface reference. Highlights:
--headless runs without a GUI (server mode), and --api-server enables the API server on startup (port 7777).--project), set up a connection (--uart, --tcp, --udp, and on Pro builds --modbus-* and --canbus), and enable exports (--csv-export, --mdf-export) from the command line.--activate/--deactivate manage a license key for CI/headless setup (Pro builds).This covers automated testing, headless data logging, and server deployments.
Yes. A JSON-RPC API with 300+ commands runs over TCP port 7777, with a gRPC server and an MCP (Model Context Protocol) wrapper on the same command surface. Scripts and AI agents can read live values, edit projects, manage sessions, and control exports. See API Reference and gRPC Server.
Yes (Pro). The in-app AI Assistant is a bring-your-own-key chat panel that works with Anthropic, OpenAI, Google Gemini, and other providers, including OpenAI-compatible local servers for offline use. Read-only commands run automatically, anything that mutates the project shows an Approve/Deny card, and device control (connect/disconnect, port settings) stays blocked unless you enable the Allow device control toggle. See AI Assistant.
Yes, if you have:
Performance depends on the Pi model and the connected display. Raspberry Pi 4 or 5 with 4 GB+ of RAM is a good starting point.
Alternatively, use the Pi as a data aggregator: collect sensor data and forward it to Serial Studio running on a desktop.
Pro only (audio input).
Use cases: audio analysis, ultrasonic sensors, software-defined radio (SDR) with audio output.
Pro only (Image View widget).
Serial Studio can display live JPEG, PNG, BMP, or WebP images streamed from any connected device over any supported transport (UART, UDP, TCP, BLE, and so on).
How it works.
The Image View widget runs an independent frame reader alongside the telemetry path. It scans the raw byte stream for image data without interfering with CSV or JSON telemetry in the same stream.
Two detection modes:
FF D8 FF … FF D9) and PNG (89 50 4E 47 … 49 45 4E 44 AE 42 60 82) frames by their magic bytes. A good fit for embedded cameras streaming raw JPEG.$IMG_START$…$IMG_END$). Configure them in the Project Editor group settings.Quick setup:
Mixed telemetry and image stream.
You can send image data and telemetry (gauges, plots, and so on) over the same connection at the same time. The Image View widget extracts image frames by magic bytes. The normal telemetry parser ignores binary image data between its frameStart/frameEnd delimiters. See the Camera Telemetry example in /examples for a full Python + project file demo.
Use cases: embedded camera modules (OV2640, ESP32-CAM), UAV video feeds, industrial vision systems, and any device that streams JPEG or PNG images over serial or the network.
Workflow:
MATLAB:
data = readtable('serial_studio_output.csv');
plot(data.Timestamp, data.Temperature);
Python:
import pandas as pd
import matplotlib.pyplot as plt
data = pd.read_csv('serial_studio_output.csv')
plt.plot(data['Timestamp'], data['Temperature'])
plt.show()
/examples folder in the GitHub repo: 10+ ready-to-use projects (Arduino, Python, project files).Free users (GPL):
Pro users:
Yes. Serial Studio is a desktop app that runs entirely offline. No internet is required except for:
Last updated: 2026-06-12