Serial Studio is an open-core, cross-platform telemetry dashboard and real-time data visualization tool for Arduino, ESP32, Raspberry Pi, and other embedded systems. It supports input from serial ports (UART), Bluetooth Low Energy (BLE), MQTT, TCP/UDP sockets, and audio devices, enabling real-time sensor monitoring, IoT data visualization, and hardware debugging without writing code.

Serial Studio runs on Windows, macOS, and Linux (including ARM64 for Raspberry Pi). It is designed for robotics teams, IoT developers, embedded systems engineers, makers, educators, and researchers who need professional telemetry dashboards and CSV data logging for sensor analysis.

Perfect for: Arduino telemetry, ESP32 dashboard, IoT sensor monitoring, robot debugging, drone flight data, environmental sensors, embedded system visualization, real-time plotting, hardware prototyping, lab data acquisition, and STEM education.

📚 New users? Check out the FAQ, use cases, and comparison with alternatives.

Serial Studio is available as source code and official precompiled binaries for Windows, macOS, and Linux.

• Latest Stable Release
• Pre-release Builds

Requires the Microsoft Visual C++ Redistributable (x64). On first launch, Windows may show a warning about an unknown developer, click "More Info → Run Anyway" to continue.

Distributed as a universal DMG. Open the DMG file and drag Serial Studio into the Applications folder. Alternatively, you can try installing via Homebrew:

brew install --cask serial-studio

Note: The Homebrew cask is community-maintained. It’s available, but not officially developed or tested by me.

The recommended way to install Serial Studio on Linux is via the official pre-built AppImage. Make it executable and run it:

chmod +x SerialStudio-Pro-3.1.10-Linux-x64.AppImage
./SerialStudio-Pro-3.1.10-Linux-x64.AppImage

If the AppImage fails to launch, your system may be missing libfuse2:

sudo apt install libfuse2

Tip: For better desktop integration (menu entries, updates, icons), use AppImageLauncher.

Serial Studio is also available on Flathub. This version receives regular updates and may offer better support for ARM64 systems. However, minor graphical glitches may occur on some desktop environments—especially under Wayland (e.g., missing window shadows).

An ARM64 AppImage is available for Raspberry Pi and similar devices. Performance varies based on hardware and GPU drivers, since the UI depends on GPU acceleration. The ARM64 AppImage requires:

• A 64-bit Linux OS equivalent to or newer than Ubuntu 24.04 (due to a glibc 2.38 dependency)
• libfuse2 installed

Make sure your system meets these requirements before running the AppImage.

• Project File Mode (recommended): Create custom dashboards using the built-in Project Editor with drag-and-drop widgets—no coding required.
• Quick Plot Mode: Instantly visualize comma-separated values from Arduino or any serial device with zero configuration.
• Device-defined Mode: Let your embedded device define its own dashboard via JSON (perfect for commercial products).

• No Coding Required: Build professional telemetry dashboards using a graphical interface
• Multi-Protocol Support: Serial/UART, Bluetooth LE, MQTT, TCP/UDP, and audio input
• 15+ Visualization Widgets: Line plots, gauges, bar charts, GPS maps, FFT spectrum, accelerometers, gyroscopes, compass, data grids
• CSV Data Export: Automatic logging of all received data for analysis in Excel, Python, MATLAB, or R
• Cross-Platform: Native apps for Windows 10/11, macOS 11+ (Intel + Apple Silicon), Linux x64, and Raspberry Pi ARM64
• Arduino/ESP32 Compatible: Works with any device that outputs data via serial, BLE, or network
• Real-Time Performance: 60 FPS dashboard updates with low latency (<50ms)
• Custom Frame Parsing: JavaScript decoder for binary protocols, checksums, and complex data formats
• MQTT for IoT: Publish and subscribe to MQTT topics for distributed sensor networks (Pro)
• Open Source: GPL-3.0 licensed core with optional commercial Pro features

Get started with Serial Studio in under 5 minutes:

• Download the latest release for your platform (see Download section)
• Windows: Run installer, allow "Unknown developer" if prompted
• macOS: Drag to Applications, right-click → Open first time
• Linux: chmod +x the AppImage and run (may need sudo apt install libfuse2)

• Launch Serial Studio
• Click the Hardware icon in the toolbar
• Select your serial port and baud rate (common: 9600, 115200)
• Click Connect

• Quick Plot Mode: Send comma-separated values from Arduino and see instant plots
• Project Mode: Use the Project Editor to build custom dashboards with gauges, maps, and more
• Examples: Explore the /examples folder for Arduino sketches, ESP32 code, and Python scripts

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 to Arduino → Connect Serial Studio → Enable Quick Plot → Done!

First-time users: See FAQ for troubleshooting and common questions.

📚 Learn More:

• FAQ - Common questions and troubleshooting
• Use Cases - Real-world applications across industries
• Comparison - Serial Studio vs. alternatives (Arduino Plotter, MATLAB, Processing, etc.)
• Examples - Arduino/ESP32/Python code and project templates
• Wiki - Complete documentation

• 📖 Wiki - Complete guides and tutorials
• ❓ FAQ - Frequently asked questions and troubleshooting
• 🎯 Use Cases - Real-world examples: robotics, IoT, drones, education, research
• ⚖️ Comparison - Serial Studio vs. Arduino Plotter, MATLAB, Processing, LabVIEW, Python
• 🤖 AI Agent Guide - For ChatGPT, Claude, and other AI assistants
• 💡 Examples - Arduino, ESP32, Python code with sample projects

• Installation: Platform-specific setup for Windows, macOS, Linux, Raspberry Pi
• Quick Start: Connect Arduino/ESP32 and visualize data in 5 minutes
• Dashboard Creation: Build custom layouts with Project Editor (no coding)
• Protocol Support: Serial/UART, Bluetooth LE, MQTT, TCP/UDP, Audio
• Frame Parsing: Handle binary protocols, checksums, custom data formats
• CSV Export: Log sensor data for analysis in Excel, Python, MATLAB, R

Minimum Requirements:

• Qt: Version 6.7 or later (6.9.2 recommended)
  • Required modules: QtCore, QtGui, QtWidgets, QtSerialPort, QtNetwork, QtCharts, QtSvg
  • Optional modules: QtBluetooth (for BLE support), QtMultimedia (for audio input)
• C++ Compiler: C++20 compatible
  • GCC 10+ (Linux)
  • Clang 12+ (macOS)
  • MSVC 2019+ (Windows)
• CMake: Version 3.16 or later
• Build Tools: Platform-specific toolchain (see below)

Platform-Specific Requirements:

sudo apt install libgl1-mesa-dev build-essential

• Xcode Command Line Tools: xcode-select --install
• Qt can be installed via Homebrew: brew install qt@6

• Visual Studio 2019 or later with C++ development tools
• Qt installed via the official installer

Once Qt is installed, you can compile the project by opening CMakeLists.txt in your preferred IDE or using the terminal:

mkdir build
cd build
cmake ../ -DPRODUCTION_OPTIMIZATION=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . -j$(nproc)

By default, the build system produces a fully GPLv3-compliant version of Serial Studio. This version includes most core features but excludes commercial modules such as MQTT, 3D visualization, XY plotting, and other advanced tools that depend on proprietary Qt components.

If you are a Pro user or have a commercial license, contact the project maintainer for build instructions and activation requirements.

Serial Studio is developed and maintained by Alex Spataru.
It is open source and community-driven, with commercial options available for users who need advanced features or business-friendly licensing.

If Serial Studio is useful to you, consider supporting its development in one of the following ways:

• Donate via PayPal: Helps keep the project active and sustainable.
• Purchase a Commercial License: Required for commercial use of the official binary. Includes Pro features and priority support.

Commercial licenses directly fund continued development, bug fixes, and new features.

Serial Studio uses a dual-license model that distinguishes between open-source usage and commercial distribution:

• LICENSE.md: summary of dual-license structure and usage terms
• LICENSES/GPL-3.0-only.txt: full GNU GPLv3 text for open-source source code
• LICENSES/LicenseRef-SerialStudio-Commercial.txt: full terms for proprietary features and official binaries

Source files are individually marked with SPDX headers indicating whether they are:

• Licensed under GPL-3.0-only
• Licensed under LicenseRef-SerialStudio-Commercial
• Or dual-licensed as GPL-3.0-only OR LicenseRef-SerialStudio-Commercial

This structure allows developers to build and distribute GPL-compliant versions while protecting commercial functionality.

The table below outlines licensing, feature access, and obligations across each edition:

Reminder: Pro features and official binaries are proprietary and require a commercial license for any use beyond personal evaluation. Visibility of source code does not imply GPL rights unless explicitly licensed.

Contributions are welcome! Whether you're fixing bugs, adding features, or improving documentation, your help is appreciated.

Before contributing:

• Check existing issues and pull requests
• Review the CLAUDE.md file for code style guidelines
• Focus on GPL-licensed code (avoid modifying commercial modules)

Code Style:

• Follow the project's clang-format configuration (LLVM base style)
• Use meaningful names for variables and functions
• Avoid inline end-of-line comments (see CLAUDE.md)
• Add Doxygen documentation for new public APIs

Submitting Changes:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes with descriptive messages
4. Push to your fork and submit a pull request
5. Ensure CI checks pass

For major changes, please open an issue first to discuss your proposal.