Overview

Relevant source files

• .github/workflows/deploy.yml
• CLAUDE.md
• CMakeLists.txt
• README.md
• app/CMakeLists.txt
• app/rcc/messages/Acknowledgements.txt
• lib/CMakeLists.txt

Serial Studio is a cross-platform telemetry dashboard and real-time data visualization application for embedded systems development. It enables developers to visualize data from hardware devices (Arduino, ESP32, PLCs, sensors) through multiple communication protocols without writing custom visualization code.

This page provides a high-level introduction to Serial Studio's architecture, capabilities, and codebase organization. For detailed information about specific subsystems, refer to:

• Build configuration and deployment: 2
• Core architecture and data flow: 3
• I/O drivers and communication: 4
• User interface and visualization: 6
• Commercial features and licensing: 9

---

Purpose and Scope

Serial Studio serves as a protocol-agnostic data acquisition and visualization platform. It abstracts hardware communication behind a Hardware Abstraction Layer (HAL), processes incoming byte streams into structured frames, and renders data through 15+ widget types at up to 60 FPS.

Primary use cases:

• Real-time sensor monitoring and debugging
• Embedded systems prototyping and testing
• Industrial equipment data logging (Modbus, CAN Bus)
• IoT device management (MQTT)
• Educational demonstrations and lab experiments

Sources: README.md1-16 CMakeLists.txt22-49

---

Supported Protocols and Data Sources

Serial Studio provides a unified interface for data acquisition across multiple transport protocols:

Protocol	Driver Class	Availability	Use Case
UART/Serial	IO::Drivers::UART	GPL + Pro	Arduino, ESP32, embedded devices
Network (TCP/UDP)	IO::Drivers::Network	GPL + Pro	Ethernet, WiFi devices
Bluetooth LE	IO::Drivers::BluetoothLE	GPL + Pro	Wireless sensors, BLE modules
MQTT	MQTT::Client	Pro only	IoT cloud platforms, distributed sensors
Modbus TCP/RTU	IO::Drivers::Modbus	Pro only	Industrial PLCs, HVAC systems
CAN Bus	IO::Drivers::CANBus	Pro only	Automotive diagnostics, DBC import
Audio Input	IO::Drivers::Audio	Pro only	Oscilloscope, FFT analysis

Sources: README.md10-14 app/CMakeLists.txt366-406 .github/workflows/deploy.yml56

---

Codebase Organization

Serial Studio follows a modular architecture with clear separation between I/O, data processing, and visualization layers:

Serial-Studio/
├── app/                          # Main application module
│   ├── src/                      # C++ source code (~100K LOC)
│   │   ├── IO/                   # Hardware abstraction and drivers
│   │   │   ├── Manager.{h,cpp}          # Central I/O coordinator
│   │   │   ├── FrameReader.{h,cpp}      # Stream-to-frame parser
│   │   │   ├── HAL_Driver.h             # Abstract driver interface
│   │   │   ├── CircularBuffer.h         # Lock-free SPSC buffer
│   │   │   └── Drivers/                 # Protocol implementations
│   │   ├── DataModel/            # Frame processing and parsing
│   │   │   ├── Frame.{h,cpp}            # Parsed data container
│   │   │   ├── FrameBuilder.{h,cpp}     # Frame construction
│   │   │   ├── FrameParser.{h,cpp}      # JavaScript parser
│   │   │   └── ProjectModel.{h,cpp}     # JSON project config
│   │   ├── UI/                   # Dashboard and widgets
│   │   │   ├── Dashboard.{h,cpp}        # Main controller
│   │   │   ├── WindowManager.{h,cpp}    # Layout engine
│   │   │   └── Widgets/                 # 15+ visualization types
│   │   ├── CSV/                  # CSV playback and export
│   │   ├── MDF4/                 # Automotive MDF4 support (Pro)
│   │   ├── MQTT/                 # MQTT client (Pro)
│   │   ├── Licensing/            # License validation (Pro)
│   │   └── SerialStudio.h        # Central enums and constants
│   ├── qml/                      # QML declarative UI
│   └── CMakeLists.txt            # Application build config
├── lib/                          # Third-party dependencies
│   ├── KissFFT/                  # FFT library
│   ├── QCodeEditor/              # Syntax highlighting
│   ├── QSimpleUpdater/           # Auto-update framework
│   ├── mdflib/                   # MDF4 file parser
│   └── OpenSSL/                  # Cryptography
├── CMakeLists.txt                # Root build configuration
└── .github/workflows/deploy.yml  # CI/CD pipeline

Sources: CMakeLists.txt1-295 app/CMakeLists.txt186-406 lib/CMakeLists.txt1-444

---

High-Level Architecture

The following diagram maps Serial Studio's conceptual layers to concrete code entities:

Key architectural patterns:

1. Hardware Abstraction Layer (HAL): All drivers inherit from HAL_Driver abstract interface, enabling protocol-agnostic data acquisition
2. Singleton Coordinators: IO::Manager, FrameBuilder, and Dashboard serve as central coordination points
3. Lock-Free Threading: CircularBuffer provides SPSC (Single Producer Single Consumer) thread-safe data path with atomic operations
4. Immutable Configuration: FrameReader achieves thread safety by immutable configuration—instances are destroyed and recreated on settings changes rather than using locks
5. Zero-Copy Dashboard Path: Dashboard::hotpathRxFrame() receives frames by const reference, avoiding heap allocations

Sources: CMakeLists.txt22-295 app/CMakeLists.txt186-300 CLAUDE.md128-451

---

Data Flow Pipeline

The following diagram traces the path of a single data frame from hardware to visualization:

Critical performance optimization (line 817):

At app/src/DataModel/FrameBuilder.cpp817 the hotpathTxFrame() function implements a zero-allocation dashboard path:

Key characteristics:

• Dashboard path: 0 allocations per frame
• Export path: 1 allocation per frame (only when enabled)
• Branch prediction hint: [[unlikely]] for export path
• Nanosecond timestamps via std::chrono::steady_clock

Sources: CLAUDE.md362-396 app/src/DataModel/FrameBuilder.cpp817 app/src/IO/FrameReader.h52

---

Build System Architecture

Serial Studio uses a three-layer CMake hierarchy for cross-platform builds:

Build options:

Option	Default	Purpose
BUILD_GPL3	ON	Force GPLv3-only build (excludes Pro modules)
BUILD_COMMERCIAL	OFF	Enable Pro features (requires license validation)
PRODUCTION_OPTIMIZATION	OFF	Enable -O3, LTO, vectorization
ENABLE_HARDENING	OFF	Security flags (stack canaries, RELRO, PIE)
ENABLE_PGO	OFF	Profile-Guided Optimization
USE_SYSTEM_ZLIB	OFF	Use system zlib (required for Flathub)
USE_SYSTEM_EXPAT	OFF	Use system expat (required for Flathub)

Build configuration examples:

Sources: CMakeLists.txt22-295 app/CMakeLists.txt1-65 lib/CMakeLists.txt1-144 .github/workflows/deploy.yml41-56

---

Licensing and Feature Distribution

Serial Studio uses a dual-license model that gates Pro features at compile-time:

Component	GPL Build	Commercial Build
UART, Network, BLE drivers	✅ Included	✅ Included
Quick Plot, Project File modes	✅ Included	✅ Included
CSV Export/Playback	✅ Included	✅ Included
Dashboard widgets (Plot, Gauge, etc.)	✅ Included	✅ Included
MQTT Client	❌ Excluded	✅ Included (MQTT::Client)
Modbus TCP/RTU	❌ Excluded	✅ Included (IO::Drivers::Modbus)
CAN Bus (DBC import)	❌ Excluded	✅ Included (IO::Drivers::CANBus)
Audio Input	❌ Excluded	✅ Included (IO::Drivers::Audio)
3D Plot	❌ Excluded	✅ Included (UI::Widgets::Plot3D)
MDF4 Export	❌ Excluded	✅ Included (MDF4::Export)

License enforcement mechanism:

1. Compile-time: BUILD_COMMERCIAL preprocessor definition controls inclusion of Pro source files app/CMakeLists.txt366-406
2. Configure-time: CMake validates commercial license via Lemon Squeezy API CMakeLists.txt243-294
3. Runtime: SerialStudio::activated() checks license status before enabling Pro features app/src/Licensing/LemonSqueezy.h

Sources: CMakeLists.txt78-294 app/CMakeLists.txt131-143 README.md85-86 README.md210-239

---

Technology Stack

Core technologies:

• Language: C++20 (concepts, constexpr, designated initializers)
• Framework: Qt 6.9.3 (Core, Gui, Widgets, Qml, Quick, Graphs)
• Build System: CMake 3.20+ with CPack packaging
• Compiler: GCC 10+, Clang 12+, MSVC 2019+

Third-party libraries:

• KissFFT: Fast Fourier Transform for spectrum analysis
• QCodeEditor: Syntax-highlighted editor for JSON/JavaScript
• QSimpleUpdater: Auto-update framework with JSON appcast
• mdflib: MDF4/MF4 automotive file format parser
• OpenSSL: Cryptography for license validation and secure communications
• ZLIB: Compression for MDF4 files
• EXPAT: XML parsing for MDF4 metadata

Lock-free concurrency:

• moodycamel::ReaderWriterQueue - SPSC wait-free queue app/src/ThirdParty/readerwriterqueue.h
• std::atomic with memory_order_acquire/release app/src/IO/CircularBuffer.h34

Sources: CMakeLists.txt22-49 app/CMakeLists.txt67-150 lib/CMakeLists.txt179-367 app/rcc/messages/Acknowledgements.txt1-440

---

Next Steps

For detailed information about specific subsystems:

• Building Serial Studio: See Build and Deployment for CMake options, CI/CD pipeline, and platform-specific packaging
• Architecture deep dive: See Core Architecture for data flow, module initialization, and threading model
• Adding hardware support: See I/O and Communication for HAL driver interface and protocol implementations
• Creating visualizations: See User Interface for QML/C++ integration, widget system, and dashboard architecture
• Commercial features: See Commercial Features and Licensing for Pro feature documentation and license management