# Serial Studio — Full Reference

> Serial Studio is a native, cross-platform desktop application (Windows 10/11, macOS 13+, Linux x86_64/ARM64, Raspberry Pi) that turns live data from hardware devices into a real-time dashboard. It connects over Serial/UART, TCP/UDP, Bluetooth LE, MQTT, Modbus RTU/TCP, CAN Bus (with DBC import), OPC UA, Siemens S7 (S7comm), EtherNet/IP (Allen-Bradley CIP), IEC 60870-5-104, audio input, raw USB (libusb), HID (hidapi) and Process I/O, decodes frames with code-free Built-In templates or custom JavaScript/Lua parsers, draws 20+ widgets, records to CSV, MDF4 or a SQLite session database, and can be automated through a setup()/loop() Control Script, a 320+ command TCP JSON API (port 7777), a gRPC streaming API (port 8888) and an MCP server for AI hosts such as Claude Desktop.

This file is the expanded companion to https://serial-studio.com/llms.txt — it carries the full feature split, pricing detail, FAQ and documentation map in a single document. The curated short version lives at /llms.txt.

- Website: https://serial-studio.com/
- Source code: https://github.com/Serial-Studio/Serial-Studio (GPLv3)
- Store: https://store.serial-studio.com/ (Lemon Squeezy)
- Developed by: Alex Spataru
- Sales/licensing: alex@serial-studio.com
- Technical support: https://github.com/Serial-Studio/Serial-Studio/issues

## What it is

Serial Studio is built for production telemetry, not just a single quick plot. It decodes structured frames, supports 10 connection drivers (not only USB serial), draws 20+ widgets, records and replays sessions, and exposes three automation surfaces (TCP, gRPC, MCP). It replaces the custom dashboard an engineer would otherwise have to build by hand.

Key facts:
- Built with Qt 6 and C++20; renders dashboards at 60 FPS with no telemetry/tracking.
- Dual-licensed: a free GPLv3 source build and a commercial Pro edition (official precompiled binaries; macOS builds signed and notarized).
- Platforms: Windows 10/11, macOS 13+ (Intel and Apple Silicon), Linux x86_64 and ARM64, Raspberry Pi. Windows available on the Microsoft Store; AppImage, deb/rpm packages, and Flathub available on Linux.
- Typical users: embedded engineers (Arduino, ESP32, STM32, Raspberry Pi), test/HIL benches, automotive/CAN work, industrial Modbus/SCADA monitoring, drone and rocketry telemetry (MAVLink, NMEA), research labs and education.

## Connection drivers (data sources)

- Serial/UART (USB, RS-232, RS-485) — free
- TCP / UDP networking — free
- Bluetooth Low Energy — free
- MQTT publish / subscribe — Pro
- Modbus RTU & TCP — Pro
- CAN Bus + DBC import (classic CAN and CAN FD) — Pro
- OPC UA (encrypted sessions, tag browsing) — Pro
- Siemens S7 (S7comm) — Pro
- EtherNet/IP (Allen-Bradley CIP) — Pro
- IEC 60870-5-104 — Pro
- Audio input (drives FFT and waterfall) — Pro
- Raw USB (libusb) — Pro
- HID devices (hidapi) — Pro
- Process I/O (child process stdout, named pipes) — Pro

## Frame decoding and data flow

- Built-In frame decoders: code-free, compiled C++ templates for delimited text, key=value, JSON, NMEA, Modbus, TLV and more — free
- Custom frame parsers in JavaScript or Lua — free
- Binary (Direct) parser mode — free
- Per-dataset transforms (EMA smoothing, scaling, calibration) — free
- CSV export and playback — free
- MDF4 / MF4 export and playback — Pro
- Session database (SQLite Explorer) — Pro
- Session reports (HTML / PDF) — Pro
- File transfer (XMODEM / YMODEM / ZMODEM) — Pro

## Widgets

- Line/multi plot, FFT, bar, gauge, compass — free
- Accelerometer, gyroscope, GPS map — free
- Data grid, LED panel, terminal — free
- 3D Plot, XY Plot, Waterfall (spectrogram) — Pro
- ImageView (live camera/image feed) — Pro
- Painter (user-scripted Canvas2D) — Pro
- Plot Sweep / Trigger mode (oscilloscope-style) — Pro
- Output widgets (buttons, sliders, knobs) — Pro

## Automation, integration and AI

- Control Loop automation — every project gets an Arduino-style setup() and loop(). setup() runs once on connect, loop() runs while connected, so a script can send wake-up handshakes, poll Modbus registers or AT commands on a timer, issue keep-alives, or step a state machine — without changing device firmware. Runs on a watchdog-protected worker thread and never blocks the dashboard. — free
- TCP JSON-RPC API on port 7777 — one command set of 320+ commands covering connection management, project editing, dashboard queries and data export. — free
- gRPC server on port 8888 — typed protobuf streaming, 5–10× faster than JSON, with clients in Python, C++, Go, Rust and more. — free
- MCP server — lets Claude Desktop and other MCP hosts drive the app. — free
- AI Assistant (in-app) — Pro. Bring-your-own-key (Anthropic, OpenAI, Google Gemini, DeepSeek, Groq, Mistral, OpenRouter) or fully offline local models (Ollama, llama.cpp, LM Studio, vLLM). It explains features, builds projects from a description, and can drive the device.
- Modbus register-map importer — Pro
- CAN DBC importer (auto-generates projects) — Pro
- Operator deployments (--runtime locked builds) — Pro. Generating a deployment that launches a project in locked operator runtime mode (read-only dashboard; connection control, AI Assistant and device writes disabled) requires Pro. The project Lock toggle itself is available in all builds; the same locked build runs on the bench and on the floor.
- Multi-device projects — Pro

## Licensing and pricing

The GPLv3 source build is free for any use, commercial included, under GPLv3 terms; it excludes the Pro modules and does not include official precompiled binaries. Pro is a commercial license with the full feature set and official installers for every platform.

Every official binary ships with a 14-day Pro trial per release — all Pro features active, no card required. After the trial you can compile the GPLv3 source for free if the standard widgets, scripting and CSV recording cover your work; activate a Pro license if you need MQTT, Modbus, CAN, MDF4 or the AI Assistant.

Plans (all include the full Pro feature set; the difference is seats and billing):
- Pro Yearly — $79.99/year (two months free compared to paying monthly). Single engineer, 5 device activations, all updates while active, email support, cancel any time.
- Pro Monthly — $9.99/month. Single engineer, 5 device activations, all updates while active, email support, cancel any time.
- Pro Lifetime — $349 one-time. Single engineer, all future Pro releases included, no subscription, 5 device activations, offline/air-gapped activation, email support. Pays back after ~35 months.
- Small Business — $39/month, or $349/year (save $119). Team up to 20, 20 device activations, operator deployments, centralized licensing and one invoice, email support.
- Enterprise — $99/month, or $799/year (save $389). Larger teams, OEMs and integrators, 100 device activations, operator deployments at scale, priority email support, custom invoicing/PO terms on request, roadmap input on industrial features.
- Test Stand — $1,200 one-time. For industrial test stands and equipment that stay in service for years: 20 device activations ($60 per device, perpetual), offline/air-gapped activation, no subscription and no phone-home, commercial/OEM/integrator use, all future Pro releases included.

Lifetime and Test Stand licenses can activate air-gapped machines offline: export a device file from the machine, generate a signed license file at https://serial-studio.com/offline-activation, and import it — no internet connection required.

Earn a Pro license by contributing: write a tutorial or video, donate development hardware, translate docs, share protocol samples or submit a pull request. Verified contributions are exchanged for a Pro license valid for 3–12 months depending on scope.

## FAQ

Q: What is Serial Studio?
A: A native cross-platform desktop application that turns data from your hardware into a live dashboard. It speaks UART, Bluetooth LE, TCP/UDP, MQTT, Modbus, CAN Bus, OPC UA, Siemens S7, EtherNet/IP, IEC 60870-5-104, audio, raw USB, HID and process I/O, and visualises the data through plots, gauges, GPS maps, FFTs, 3D views and a scriptable Canvas2D widget.

Q: Is Serial Studio free?
A: Yes. The GPL-3.0 source build is free and covers Serial/UART, TCP/UDP and Bluetooth LE with 15+ widgets, CSV export, JavaScript and Lua frame parsers, the TCP API and MCP server. Pro adds MQTT, Modbus, CAN Bus, OPC UA, Siemens S7, EtherNet/IP, IEC 60870-5-104, audio, USB, HID, the 3D and waterfall widgets, MDF4, session database, the AI Assistant and more. Pro starts at $9.99/month, with a $349 lifetime option.

Q: Which platforms does Serial Studio run on?
A: Windows 10 and 11, macOS 13 and later (Intel and Apple Silicon), Linux x86_64 and ARM64, and Raspberry Pi. An AppImage, deb/rpm packages, and a Flathub package are also available.

Q: Can Serial Studio decode CAN Bus DBC files?
A: Yes. The Pro CAN Bus driver imports DBC files and decodes signals automatically for classic CAN and CAN FD. Logs can be exported and replayed as MDF4.

Q: Does Serial Studio support MQTT?
A: Yes, in the Pro edition. Serial Studio can publish telemetry from local hardware to an MQTT broker and subscribe to topics from anywhere, bridging your bench equipment into an IoT pipeline.

Q: Can I use Serial Studio commercially?
A: Yes. The free GPLv3 build may be used commercially under the GPL's terms; it excludes the Pro features. For MQTT, Modbus, CAN and the other Pro modules, official binaries, or proprietary integration without copyleft obligations, choose Pro, Small Business or Enterprise.

Q: How does Serial Studio compare to Arduino IDE Serial Plotter or PuTTY?
A: Serial Studio is built for production telemetry, not just a single plot. It decodes structured frames with code-free Built-In templates or JavaScript and Lua parsers, supports 14 bus drivers (not only USB serial), draws 20+ widgets, records and replays sessions to CSV or MDF4, and exposes a TCP API, gRPC server and MCP server for automation. The Arduino Serial Plotter and PuTTY are useful for quick checks; Serial Studio replaces the custom dashboard you would otherwise have to build.

Q: Can Serial Studio automate a connected device?
A: Yes. The Control Loop gives every project an Arduino-style setup() and loop(). setup() runs once when the device connects and loop() runs while it stays connected, so the script can send wake-up handshakes, poll Modbus registers or AT commands on a timer, issue keep-alives or step a state machine, all without changing the device firmware. It runs on its own watchdog-protected worker thread and never blocks the dashboard.

Q: Does Serial Studio have an API?
A: Yes, three surfaces that share one command set of 320+ commands: a TCP JSON-RPC API on port 7777, a gRPC server on port 8888 with typed protobuf streaming (5 to 10 times faster than JSON, clients in Python, C++, Go, Rust and more), and an MCP server so Claude Desktop and other MCP hosts can drive the app. The API covers connection management, project editing, dashboard queries and data export.

Q: How do I visualize Arduino data with Serial Studio?
A: Print comma-separated values from your Arduino sketch, open Serial Studio, pick the serial port and baud rate, then enable Quick Plot mode. For a structured dashboard with gauges, maps and 3D views, define your data format in the Project Editor or let the AI Assistant generate the project for you.

## Quick start

1. Download and install Serial Studio for your OS from https://serial-studio.com/. Every binary ships with a 14-day Pro trial.
2. Launch it, pick a driver (Serial, BLE, TCP/UDP, MQTT, Modbus, CAN, OPC UA, S7, EtherNet/IP, IEC 104, audio, USB, HID or Process I/O), select your device and click Connect.
3. Send comma-separated values to enable Quick Plot, or open the Project Editor to design a custom dashboard with plots, gauges, GPS maps and 3D views.

## Main pages

- [Home](https://serial-studio.com/): product overview, feature list, downloads for Windows, macOS, Linux and Raspberry Pi, FAQ
- [Pricing](https://serial-studio.com/pricing): free GPLv3 build vs Pro comparison table, plans, licensing FAQ
- [Help Center](https://serial-studio.com/help): full documentation, 73 static topic pages at https://serial-studio.com/help/<topic>, each with a raw markdown twin at /help/<topic>.md. /help documents the current release; earlier releases live at /help/<version>/<topic> (e.g. /help/v4.0.2/getting-started) and the development build at /help/dev/<topic>
- [Examples](https://serial-studio.com/examples): 30+ open-source example projects with project files and firmware
- [Extensions](https://serial-studio.com/extensions): community add-ons, frame parsers, Painter widgets and themes
- [Gallery](https://serial-studio.com/gallery): screenshots of real dashboards
- [Comparison](https://serial-studio.com/comparison): Serial Studio vs Grafana, Arduino Serial Plotter, LabVIEW, MATLAB, Python/PySerial, Processing, PuTTY/TeraTerm, CoolTerm and Plotly Dash
- [Blog](https://serial-studio.com/blog): tutorials and build logs applying Serial Studio to real industries; RSS feed at /blog/feed.xml, each post has a raw markdown twin at /blog/<slug>.md

## Documentation (markdown sources)

- [Getting Started](https://serial-studio.com/help/getting-started.md): install, connect, first dashboard
- [Operation Modes](https://serial-studio.com/help/operation-modes.md): Project File, Quick Plot and Console modes
- [Frame Parser Reference](https://serial-studio.com/help/javascript-api.md): Built-In templates, JavaScript and Lua parsers
- [Control Script](https://serial-studio.com/help/control-script.md): setup()/loop() device automation
- [API Reference](https://serial-studio.com/help/api-reference.md): TCP JSON API, 320+ commands
- [gRPC Server](https://serial-studio.com/help/grpc-server.md): typed protobuf streaming API on port 8888
- [AI Assistant](https://serial-studio.com/help/ai-assistant.md): in-app assistant, supported providers and safety model
- [OPC UA Driver](https://serial-studio.com/help/drivers-opc-ua.md): endpoint discovery, tag browsing, subscriptions, security policies (Pro)
- [Siemens S7 Driver](https://serial-studio.com/help/drivers-s7.md): S7comm polling by absolute address on S7-300/400/1200/1500 (Pro)
- [EtherNet/IP Driver](https://serial-studio.com/help/drivers-ethernet-ip.md): Allen-Bradley Logix tags by symbolic name (Pro)
- [IEC 60870-5-104 Driver](https://serial-studio.com/help/drivers-iec-104.md): telecontrol client for substations, RTUs and SCADA gateways (Pro)
- [Remote Dashboard](https://serial-studio.com/help/remote-dashboard.md): watch another instance's dashboard read-only over the TCP API, all editions
- [Command Palette](https://serial-studio.com/help/command-palette.md): Ctrl+K search across every workspace, widget, tool and command
- [Console Annotations](https://serial-studio.com/help/console-annotations.md): JavaScript protocol decoders that label byte ranges in the console stream
- [Pro vs Free](https://serial-studio.com/help/pro-vs-free.md): exact feature split between GPLv3 and Pro
- [FAQ](https://serial-studio.com/help/faq.md): common questions
- [Comparison with Alternatives](https://serial-studio.com/help/comparison.md): vs Arduino Serial Plotter, PuTTY, custom scripts
- Complete topic index (73 pages, all sections): https://serial-studio.com/help

## Blog (markdown sources)

Educational, search-intent posts: a reader looking up a concept (serial port, MQTT, CAN, Modbus) lands here and meets Serial Studio as the tool to see the data.

- [What Is Serial Studio? A Tour of the Dashboard App](https://serial-studio.com/blog/what-is-serial-studio.md): the anchor overview — the "device sends data, host decides what it means" model; Console/Quick Plot/Project File modes; fourteen drivers; 15+ widgets; built-in/JS/Lua parsers; transforms; CSV/MDF4 recording; TCP/gRPC/MCP APIs; Qt6/C++20 native; free GPL vs Pro
- [Serial Studio Isn't Just for Serial Ports](https://serial-studio.com/blog/not-just-serial-ports.md): corrects the misconception — one frame-reading pipeline behind every driver; free UART/TCP-UDP/BLE and Pro MQTT/Modbus/CAN/audio/USB/HID/Process I/O (the last reads a program's stdout, so any script becomes a source)
- [Build Serial Studio From Source (GPLv3)](https://serial-studio.com/blog/build-serial-studio-from-source.md): compile the open-source edition — Qt 6.9+ (6.11.1 rec), C++20 (GCC10+/Clang12+/MSVC2019+), CMake 3.20+; Linux/macOS/Windows setup; `cmake -B build`/`cmake --build`; what the GPL build includes vs the Pro-only modules; commercial use of the GPL build is permitted under GPLv3 terms
- [Why Serial Studio Has a Pro License](https://serial-studio.com/blog/why-serial-studio-has-a-pro-license.md): first-person essay — started MIT, needed Qt modules (QtGraphs) that require GPLv3 or a commercial Qt license, so adopted Qt's dual-license model; full source public including activation; SPDX headers mark GPL vs commercial; one repo keeps the GPL build maintained; open source ≠ free support; the FOSS abandonware/burnout problem and the xz-utils backdoor as a cautionary example of unfunded solo maintainership; trial resets per version; solo-dev sustainability
- [No, Your Device Doesn't Have to Send JSON](https://serial-studio.com/blog/json-misconception.md): the misconception that a device must output JSON because the Project Editor uses JSON — the `.ssproj` is host-side dashboard config; the wire format is independent (CSV/Quick Plot, binary, delimited, MAVLink/NMEA/MessagePack/etc.), bridged by the frame parser
- [Activate Serial Studio Pro Offline](https://serial-studio.com/blog/activate-pro-offline.md): air-gapped activation (lifetime and test-stand licenses only; permanently consumes a seat) — export `.ssmachine` from About→Manage License→Activate Offline, upload at /offline-activation with email+key, import the returned `.sslic`; bound to the machine ID
- [How to Read Data From a Serial Port](https://serial-studio.com/blog/how-to-read-a-serial-port.md): fundamentals — UART, baud rate, 8N1 framing, COM/`/dev/tty`/`/dev/cu` paths, Quick Plot, DTR-reset and baud-mismatch pitfalls
- [Serial Monitor on macOS: Terminal Tools and a Native App](https://serial-studio.com/blog/serial-monitor-macos.md): macOS has no built-in GUI serial monitor; finding `/dev/cu.*`, `cu.*` vs `tty.*`, the limits of `screen`/`cu`, Serial Studio as the native alternative
- [What Is MQTT?](https://serial-studio.com/blog/what-is-mqtt.md): publish/subscribe, brokers, topics and wildcards, quality of service; grounded in HSL Helsinki's public transit feed (`mqtt.hsl.fi`) so it needs no hardware
- [Frame Parsers: How Bytes Become Datasets](https://serial-studio.com/blog/frame-parsers-and-the-empty-parser.md): the data-ownership model — Quick Plot, built-in templates, custom `parse()`, and why the frame parser must return empty when the Control Loop owns the data (avoids double export)
- [What Is the CAN Bus?](https://serial-studio.com/blog/what-is-can-bus.md): multi-master broadcast, arbitration IDs as message identity not addresses, DBC decoding, VirtualCAN + ECU simulator for hardware-free practice
- [What Is Modbus? A Practical Field Guide](https://serial-studio.com/blog/what-is-modbus.md): request/response master/slave, the four register tables, RTU vs TCP, function codes, the 40001-vs-address-0 numbering gotcha and register scaling
- [Calibrate Sensor Data: Counts to Real Units](https://serial-studio.com/blog/sensor-data-transforms.md): per-dataset `transform(value)` for calibration/unit-conversion/filtering (with persistent state), and shared data tables (constant vs computed registers, `tableGet`/`tableSet`) so a calibration value or running total is owned in one place
- [A Plot's X Axis: Time, Samples, or Custom](https://serial-studio.com/blog/plot-x-axis-time-samples-custom.md): a plot's X axis can be Time (scrolling, host arrival clock), Samples (index 0..N, for bursty/untimed data), or Custom (Pro — `xAxisId` points at another dataset for XY/phase/I-V/trajectory plots); covers using a device `timestamp` dataset as the X axis and returning multiple rows per frame
- [An Arduino Serial Plotter Alternative](https://serial-studio.com/blog/arduino-serial-plotter-alternative.md): the IDE plotter is fine for a first look but has one shared chart/scale, a short fixed window and no export; Quick Plot reads the same comma-separated `println` output with one plot per channel, CSV session recording and console scrollback — a text-only first line (e.g. `Serial.println("Moisture,Light")` in `setup()`) names the channels
- [Send ESP32 Sensor Data Over Wi-Fi](https://serial-studio.com/blog/esp32-send-sensor-data-wifi.md): make the ESP32 a small `WiFiServer` TCP server (port 3333) streaming one CSV line per sample; Serial Studio's free network driver connects as TCP client (Quick Plot decodes, per-connection header names channels); UDP alternative for send-and-forget (set the local UDP port), BLE for network-less wireless
- [What Is Telemetry? How Live Data Gets Home](https://serial-studio.com/blog/what-is-telemetry.md): telemetry = measurement at a distance; every system shares the sense→sample→encode(frame)→transmit→decode chain; downlink (telemetry) vs uplink (telecommand); counts-not-units, timestamps-as-data and framing/checksums as the classic problems; a desktop ground station closes the chain
- [Draw a Custom Dashboard Widget With Canvas2D](https://serial-studio.com/blog/custom-widgets-canvas2d-painter.md): the Painter widget (Pro) runs a user script with Canvas2D-style drawing — `paint(ctx, w, h)` redraws everything at the refresh rate (60 Hz default, 1–240 Hz), optional `onFrame()` holds state (peak hold, trails) in top-level variables; `datasets[i].value/min/max/title/units` and `frame.timestampMs` expose live data; a `theme` object (widget_base, accent, alarm, …) keeps custom widgets theme-correct; `ctx.arc` maps to native arc-path (precede partial arcs with `moveTo`); a 250 ms watchdog kills runaway paints; 18 bundled templates (oscilloscope, radar sweep, artificial horizon, heatmap, VU meter, 7-segment, polar, XY scope …) serve as starting points
- [Vibration Analysis With a Sound Card and FFT](https://serial-studio.com/blog/vibration-analysis-sound-card-fft.md): a piezo disc + line-in as an uncalibrated vibration analyzer — conditioning (1 MΩ load, series R, back-to-back diode clamp, DC-block cap, ideally a buffer); sound-card limits (AC-coupled ~10–20 Hz corner, audio anti-alias filters, arbitrary amplitude units, no ISO 20816 judgments); fault signatures (1× imbalance, 2× misalignment, harmonics looseness, non-integer bearing tones, gear mesh + sidebands); waterfalls separate speed-tracking orders from fixed resonances during run-up/coast-down; the audio input driver (Pro) makes each channel a dataset at one frame per sample (48 kHz = 48,000 frames/s), Quick Plot auto-configures the FFT, in projects set fftSamplingRate to the device rate; FFT plot is free, Waterfall is Pro
- [Send SCPI and G-code From Your Dashboard](https://serial-studio.com/blog/control-devices-scpi-gcode.md): the write path — SCPI (IEEE 488.2 layer; colon tree, short/long keyword forms, `?` queries, `*IDN?`/`*RST`/`*OPC?`; USB-TMC, raw TCP 5025, serial; `\n` terminated) and Grbl (one `ok`/`error:N` per line, realtime `?` `!` `~` Ctrl-X bypass the buffer, `$J=` jogs check soft limits and don't disturb modal state); why control beats monitoring in difficulty (exact formatting, ack handling, reply/telemetry interleaving, render reported not desired state); output widgets (Pro: buttons, toggles, sliders, knobs, text fields) format outbound bytes via an editable JavaScript `transmit(value)` template, with bundled SCPI/G-code/Grbl/Modbus/CAN/AT/PWM/PID templates and a transmit test dialog; e-stop must stay hardware
- [Binary Serial Protocols: COBS & MessagePack](https://serial-studio.com/blog/binary-serial-protocols-cobs-messagepack.md): when text framing runs out — 8N1 = 10 bits/byte so 115200 baud carries 11,520 B/s (a 21-byte CSV line caps at ~548 lines/s; the same record binary-packed at ~16 bytes on the wire gives 720/s); AVR float printf costs ~1.5 KB flash vs a 4-byte memcpy; COBS (Cheshire & Baker 1999) eliminates 0x00 from payloads via distance-to-next-zero code bytes (`11 22 00 33` → `03 11 22 02 33 00`, ≤1 overhead byte per 254) so the 0x00 delimiter gives instant resync; MessagePack is self-describing binary (3×float32+uint16 = 19 bytes vs 31 CSV; pin floats to 32-bit; mpack/ArduinoJson/CircuitPython on the MCU side); built-in "COBS-encoded frames" and "MessagePack data" (array/map) parser templates decode them over the Binary decoder (Pro), custom parsers get byte arrays (JS DataView / Lua string.char); the parse hot path is CI-gated at 256,000 frames/s (Lua numeric), pipeline at 4×; text remains right at low rates (terminals, logic analyzers, visible corruption)
- [Monitor Multiple Devices on One Dashboard](https://serial-studio.com/blog/multiple-devices-one-dashboard.md): multi-device mode (Pro; the free edition connects to one source) — a project defines several Sources, each with its own bus type, connection settings, framing/checksum and optional JS/Lua frame parser, so mixed transports (UART + TCP + BLE + MQTT …) run side by side; Connect opens every device at once; each source has its own frame reader and isolated script engine so a noisy device can't stall or corrupt another; groups/widgets belong to a source; CSV/MDF4 recording and playback capture all sources on one timeline, the console is per-device and output widgets target a single device; covers the merge-at-source (aggregator firmware) vs merge-at-host trade-off; demoed by the Dual Drone Telemetry example (two TCP ports 9001/9002, distinct hex delimiters, JPEG camera frames interleaved with CSV, a Crash control that drops one link while the other keeps streaming)
- [Telemetry You Can Trust: Lessons from Production Firmware](https://serial-studio.com/blog/telemetry-lessons-from-production-firmware.md): nine firmware habits, each paired with the Serial Studio machinery that holds up the host's end — driver-side validity (fault registers, rail rejection, plausibility bands, warm-up windows) mirrored by a quality-flag computed register that taints every derived channel; in-band sentinels (J1939 0xFF/0xFE, NAMUR NE43 live zero) caught by transforms returning NaN for a plot gap, with alarm limits in Constant registers and a virtual dataset as the status channel; scaled integers on the wire with slope/offset in calibration data-table registers (the Calibration from Data Table template) and derived quantities (power = V×I) recreated host-side via datasetGetFinal() in tree order; wire integrity matched to the link (CAN's hardware CRC needs no payload checksum; UART and UDP do — the per-source checksum stage drops failing frames before parse(), nine algorithms from XOR-8 to CRC-32/Adler-32) plus a rolling frame counter à la MAVLink, with a transform turning counter gaps into a dropped-frames register and virtual dataset; timestamping answered at the source (sample counters × crystal-timed read period, per-sample device timestamps for batched data, GPS PPS/PTP when boards must share t = 0; simultaneous-sampling vs muxed ADCs for cross-channel alignment) and consumed by mapping device time as a dataset for a plot's custom X axis, while transforms' info.timestampMs stays host-side plumbing; transmit-by-exception on the device (suppressed all-invalid frames, diagnostics only while faulted, a slow identity frame as the aliveness proof) matched by a Control Script staleness watchdog (io.getLatestFrame().ageMs → tableSet + refreshDashboard(), view-only, plus notifyCritical), with loop() itself on a watchdog-protected worker thread; boxcar-average before decimating on the device because aliased mains becomes DC no host filter can remove (EMA/median transforms only polish); watchdog discipline, boot frames with reset cause, and retrospective delivery checks (an error-passive CAN node accepts frames it never delivers), answered by clearPlots() on a reboot sentinel and setActiveWorkspace() on mode transitions (gated on change, never per frame); and simulation two ways — external (UDP script, VirtualCAN + DBC) or fully in-app, where the Control Script writes data tables and calls dashboardTick() (renders and exports, seeds the frame structure) while parse() returns an empty array so nothing exports twice
- [Checksums and CRC, Explained](https://serial-studio.com/blog/checksums-and-crc-explained.md): what a checksum catches (bit-level corruption within a frame) vs what it can never catch (a whole frame going missing — pairs with the production-firmware post's sequence-counter habit); why a plain XOR/sum is blind to swapped bytes and paired bit flips while a CRC's polynomial division provably catches every burst error under n bits; named variants in the wild (CRC-8 for short low-stakes frames, CRC-16 as the Modbus RTU and MAVLink workhorse, MAVLink's added CRC_EXTRA per-message seed byte, CRC-32 for large payloads, CAN's own hardware 15-bit CRC needing no payload checksum); where the check value sits in a frame (COBS payload vs NMEA's literal `*` delimiter); Serial Studio's built-in per-source checksum stage (XOR-8, MOD-256, CRC-8, three CRC-16 flavors, Fletcher-16, CRC-32, Adler-32) drops failing frames before parse() runs, and the shipped NMEA 0183 Lua parser recomputes the XOR itself and holds the last known-good reading on mismatch; the TinyGPS example demonstrates it with no hardware; a CRC has no secret key and is not a security control
- [Serial Monitor on Windows: Terminal Tools and a Native App](https://serial-studio.com/blog/serial-monitor-windows.md): Windows COM port naming and the silent renumbering problem when a USB-serial adapter gets replugged; where PuTTY, Tera Term and the Arduino IDE's Serial Monitor actually stop (a scrolling text pane, no live numeric plotting, no export, no multi-channel view); CH340/CP210x/FTDI driver quirks worth knowing; Serial Studio as the native Windows GUI alternative when a plot or gauge beats a terminal
- [Alarms and Notifications](https://serial-studio.com/blog/alarms-and-notifications.md): the notify*() scripting API (level/channel/title/subtitle event shape) for flagging a threshold instead of watching a plot for it; latching alerts as a scripting pattern (a `latched` boolean plus notifyClear with a hysteresis gap), not a UI checkbox; the Notification Log widget (auto-scroll, unread badge, case-sensitive filter, history cleared on every dashboard reset); an opt-in OS tray toast for Warning/Critical events; Pro-only; demoed by adding one notify() call to the Modbus PLC Simulator's own documented pressure threshold
- [Data Logging and Session Replay in Serial Studio](https://serial-studio.com/blog/data-logging-and-session-replay.md): three recording paths (CSV, MDF4, Pro session database) all writing in the background on batched transactions so disk I/O never blocks the live dashboard; the session database keys readings/raw_bytes/table_snapshots by timestamp and embeds the project as JSON so a session recorded months ago still replays correctly; CSV (universal, zero setup, free) vs MDF4 (compact binary, per-channel sample rates and units, Pro, fits existing automotive/industrial MDF tooling like asammdf/CANape/DIAdem) tradeoffs; replay renders the dashboard from the stored parsed values, not by re-running raw bytes through the frame parser; the Session Explorer adds tagging, notes, HTML/PDF reports and password-locking; demoed hardware-free with the Modbus PLC Simulator and CAN Bus Example
- [Your First Serial Studio Project](https://serial-studio.com/blog/your-first-serial-studio-project.md): the from-zero on-ramp every other post assumes you've already done — Quick Plot needs no project file at all, just a CSV-like `println` line, before the walkthrough moves to the Project Editor (New → frame detection → Add Group → Add Dataset → save → Connect); cross-links the json-misconception post (the `.ssproj` is host-side JSON config, not a wire-format requirement) and not-just-serial-ports (every other source once you're past the first plot)
- [Serial Studio With STM32 and Raspberry Pi Pico](https://serial-studio.com/blog/stm32-and-pico-with-serial-studio.md): the core point — Serial Studio reads bytes off a serial port, USB CDC or Wi-Fi link regardless of MCU brand; a minimal STM32 example (HAL_UART_Transmit, or printf retargeted through a `_write` override) and a Raspberry Pi Pico example (`stdio_init_all()` routing printf to USB CDC, or UART0/UART1 directly), both emitting the same comma-separated newline-terminated line Quick Plot already expects; the real difference from Arduino/ESP32 is the toolchain setup (CubeMX/CubeIDE and clock trees vs `Serial.begin()`), not the day-to-day serial experience once flashed
- [What Is MAVLink? Drone Telemetry Explained](https://serial-studio.com/blog/what-is-mavlink.md): message IDs as broadcast meaning rather than an address, echoing (but not equating to) the CAN arbitration-ID parallel; MAVLink's CRC-16 plus a per-message CRC_EXTRA seed byte that turns a misparsed field into a checksum failure instead of silently-wrong data; ATTITUDE/VFR_HUD/GLOBAL_POSITION_INT decoded by a built-in, no-code MAVLink frame-parser template in both Free and Pro, with Lua/JS reference parsers for anything beyond those three messages; the free-tier UDP driver for a companion-computer link; the bundled Dual Drone Telemetry example is a look-alike hex/CSV simulator, not real MAVLink, and the post says so plainly
- Blog index (all posts, RSS at /blog/feed.xml): https://serial-studio.com/blog

## Downloads

- [GitHub Releases](https://github.com/Serial-Studio/Serial-Studio/releases/latest): official installers (Windows .msi, macOS .dmg, Linux AppImage x64/arm64)
- [Flathub](https://flathub.org/apps/com.serial_studio.Serial-Studio): Linux Flatpak package
- macOS Homebrew: `brew install --cask serial-studio`

## Purchase and contact

- [Store](https://store.serial-studio.com/): Pro, Small Business and Enterprise licenses (Lemon Squeezy)
- Sales and licensing: alex@serial-studio.com
- Technical support: https://github.com/Serial-Studio/Serial-Studio/issues