Embedded telemetry · live

Watch your microcontroller think.

Kymotrace streams measurements from Arduino, ESP32 and STM32 to your desktop – compact, non-blocking and live. Plot them as curves, XY traces or in 3D, analyse them and export them.

Download KymoStudio See how it works

9–21bytes per data point
256channels, own rate each
0heap, RTOS or blocking

CH 0+0.000

RATE50 Hz

FRAME9 B

Serial.print is not a measuring instrument.

Text over serial

Formatting costs CPU time and blocks the loop
One number per line, one curve at best
Parsing on the PC breaks on every typo

Kymotrace frames

Binary float32 – 9 bytes, sent without waiting
Up to 256 channels with X, Y, Z and time
Self-synchronising, optional CRC

From sensor to screen in three parts.

Each part works on its own – together they form a complete measurement chain.

A
KymoCore

Library in your microcontroller

Portable C++11 with a C API. Schedules your channels, encodes them into 9–21 byte frames and hands them to any transport – without heap, RTOS or blocking.
kymocore on GitHub →PlatformIO Registry →
B
KymoProbe

Ready-made firmware

Examples for ESP32, Arduino Uno/Nano/Mega and STM32 – over UART, USB or Wi-Fi with MQTT. Flash it, connect, see data within minutes.
kymoprobe on GitHub →
C
KymoStudio

Desktop workbench

Receives several sources at once, draws time series, XY and 3D charts, analyses raw data and exports CSV and PNG. Windows installer; runs from source on Linux and macOS.
kymostudio on GitHub →

Transport UART · USB · TCP · MQTT · CAN / Frame A5 5A · 41 · 07 · 00 00 80 3F · 00

KymoStudio – precise, calm, honest.

A workbench that feels like a good measuring instrument: it always shows whether data arrives, whether anything is lost and what you are looking at.

KymoStudio workbench with a time series of three signals and an XY chart with circle and Lissajous figure

Many sources at once

Serial, TCP, MQTT, CAN and a built-in test generator – each started and stopped on its own.

Four chart types

Time series, XY line, XY scatter and XYZ in 3D. X and Y come straight from the data packet.

Understands your data

Kymotrace binary, plain numbers or JSON – detected automatically.

Analysis on raw data

Min, max, mean, RMS and standard deviation – computed from the stored raw data, not the decimated display.

Pause, keep recording

Freeze the display while acquisition keeps running. Buffers are bounded – the status bar counts anything dropped.

Export everything

Raw data as CSV, the workspace as PNG, the configuration as JSON.

XY chart in KymoStudio with a circle and a Lissajous figure

Real XY traces, not just curves over time.

When a frame carries X and Y, KymoStudio draws the path itself: characteristic curves, robot trajectories, phase portraits or Lissajous figures – live, zoomable, with crosshair readout.

Made for the bench, the lab and the workshop.

Control loopsSetpoint, actual value and output of a PID controller side by side while you tune it.
Sensor developmentNoise, drift and step response – visible and backed by statistics.
Drives & powerCurrent, voltage, speed and position with timestamps, in parallel.
Robotics & motionPaths and positions as XY or 3D instead of columns of numbers.
Test benchesMany channels in parallel, CAN and MQTT next to serial sources – with counters that show if anything is dropped.
Teaching & makersMake physics and electronics tangible – the demo needs no hardware at all.

Every byte earns its place.

Build a frame yourself. Toggle the optional fields and watch layout, length and checksum change – these are the exact bytes on the wire.

X Z Time CRC-8

SYNCDESCID XYZTIMECRC / 00

Two calls. That's the API.

Describe your channels once, call Kymo_Init() at start-up and Kymo_Main() in your loop. KymoCore decides which channel is due, asks your callback for the value and never waits for the interface.

Arduino Uno · Nano · Mega
ESP32 · S3 · C3
STM32 F1 · F4
C99 / C++11

Install from the PlatformIO Registry:

lib_deps = codename666/KymoCore@^6.2.3

KymoCore on PlatformIO →

// kymo_config.cpp – your measurement
static uint8_t sample(void *, uint8_t id, KymoSample *out)
{
    out->value = id == 0 ? readTemperature() : readPressure();
    return 1;
}

static const KymoChannel channels[] = {
    {20,  0, 0},   // channel 0 every 20 ms
    {100, 1, 0}    // channel 1 every 100 ms
};

// main.cpp
static KymoContext kymo;
void setup() { Serial.begin(115200); Kymo_Init(&kymo, &kymo_config); }
void loop()  { Kymo_Main(&kymo); }

Live data in three steps.

1
Install KymoStudio

Download the Windows installer from the latest release – or run it from source on Linux and macOS.
Download installer SHA256
2
Flash a board

Clone KymoProbe and upload the ESP32 example – or add KymoCore from the PlatformIO Registry to your own project.
```
pio run -e nodemcu-32s -t upload
```
3
Connect

Open a serial connection at 115200 baud, 8N1. Frames are detected automatically – assign a channel to a chart and watch.

No board yet? Start the demo inside KymoStudio.

Free for makers. Fair for companies.

Hobby · learning · open source

GPLv3

Free

All three projects, full source
Use, modify and share
Distributed derivatives stay open source (GPLv3)

Get the source

Companies · products

Commercial

On request

Ship devices without disclosing your firmware
Use in proprietary products
Support and invoice on request

Licensing details

KymoStudio builds on Qt Charts and Qt Quick 3D. Redistributing KymoStudio in a proprietary product additionally requires a commercial Qt license for these modules – see the licensing details.