The engine behind Kymoscope,
under your own UI.

Kymoscope SDK gives you the engine of the Kymoscope app for sensor and test data: file and folder import, laps, worksheets of synchronised charts, math channels, multi-gigabyte files and end-to-end encrypted live streams. You build the interface; your data stays on your servers.

Read the quickstart Browse the docs

Rig monitor

A small host app built on the SDK: its toolbar, menu and grid are this page's code; the charts, the 30 Hz stream and the settings dialog are the engine.

Feed it, chart it, keep it

One API for plain pages and React apps. The Kymoscope web app is built on it too: its source rail, menus and dialogs are one UI over the engine.

Chart: Add chart models with engine.charts.add() and mount them into your layout with engine.charts.mount() or <Chart>.
Feed: Add columns from arrays, CSV text or files; push live samples from the page or join an encrypted stream.
Keep: Subscribe to state changes and export the workspace as JSON with engine.io. Store it with the rest of your data.

<link rel="stylesheet" href="/vendor/kymoscope/styles/charts.css" />
<button id="import">Import folder</button>
<div id="chart" style="height: 360px"></div>

<script src="/vendor/kymoscope/kymoscope-embed.js"></script>
<script>
  const engine = Kymoscope.createEngine({ licenseKey: LICENSE_KEY })

  engine.datasets.addColumns({ name: 'Run 42', columns: { t, rpm, torque } })
  const chartId = engine.charts.add('multiband', { title: 'Engine' })
  engine.charts.addSeries(chartId, 'rpm')
  engine.charts.mount(chartId, document.getElementById('chart'))

  // Your button, your UI: the engine does the work.
  document.getElementById('import').onclick = async () => {
    const entries = await engine.folders.pick()
    if (entries) await engine.datasets.importFiles(entries.filter((e) => engine.folders.isImportable(e.path)))
  }
</script>

Specifications

@kymoscope/sdk 0.1.0

Parameter	Value	Notes
Chart kinds	27	Multi-band time series, XY with polynomial fit, 3D mesh, FFT spectrum, spectrogram, histograms, SPC control charts, box, violin, heatmap, ROC and more
Live buffer	12,000 samples	Per stream, drawn every animation frame straight from the ring buffer, outside React
File size in the browser	Up to 2–4 GB	Files over 100 million values or 300 MB go out of core into DuckDB-WASM; the ceiling is the browser’s WASM memory. 200 MB+ files tested
Stream encryption	AES-256-GCM	Key derived from the stream password with PBKDF2 (600,000 iterations) in the viewer’s browser
Relay credential	2 min tickets	Watch-only, one stream, renewed automatically; minted by your backend, so your API key never reaches a browser
Distribution	ESM + <script>	Headless engine with optional React bindings, and a standalone build with React bundled; TypeScript declarations included
Styling	CSS variables	Charts carry no chrome; four colour variables, light and dark schemes, your fonts
License check	Offline, Ed25519	Domain-bound keys verified in the browser; no call home

Three ways in

A headless engine

Datasets, worksheets, charts and live streams as an API with state and events. From a script tag or a bundle, in any framework.

Core concepts

Bare charts for your layout

27 chart kinds with no toolbars or menus. You build those; charts report status and gestures as events.

Building your own UI

Encrypted live streams

Publish from Python (pip install kymoscope), a native plugin or any WebSocket client. Viewers decrypt in the browser with the stream password.

Live streams

What your users get

Engineering charts, not dashboards: Stacked multi-band traces with independent scales, linked zoom across panels, crosshair readouts, alarm lines, XY fits and FFTs, all tuned for dense sensor data.
Math channels: Users derive signals with formulas: arithmetic, filters, derivative, integral, moving average, lag and lead. Store them in your backend through a four-method adapter.
Huge files, still in the browser: Small files load into memory; large ones stream into DuckDB-WASM and are decimated per viewport, so zooming stays sharp.
Overlay runs: Compare datasets and laps on one axis, shift them in time, colour them per run.
Portable workspaces: Worksheets, charts and settings serialise to one JSON document. Save it anywhere; load it back with one call.
Your product’s rules: Pass limits for charts, worksheets and channels; the engine refuses the action and emits a limit event, so upgrades happen in your UI.

Your data stays yours

The SDK runs entirely in the browser. You serve the files and the workspace JSON, so nothing your users analyse ever touches Kymoscope infrastructure.

Live data is the one thing that crosses a Kymoscope service, and it crosses encrypted. Publishers seal every frame; the relay forwards bytes it cannot read.

How data flows

PublisherPython, C++ plugin, any languageencrypts frames

RelayForwards ciphertext only; never holds a keyours or yours

Your browserSDK · charts, math, DuckDBdecrypts AES-256-GCM

Your backendDatasets, workspace JSON, watch tickets · plaintext stays with you

Kymoscope serversNever receive your files or workspace data

Built for teams that ship to engineers

Data-logger and DAQ vendors

Give customers a web viewer for your recordings and a live view of connected devices, in your own interface, without building a charting team.

Test labs and customer portals

Publish test results as interactive charts your clients explore themselves, inside your own portal.

Motorsport and vehicle telemetry

Lap overlays, math channels and live pit-wall views from any language that can open a WebSocket.

Industrial and IoT platforms

Add engineering-grade analysis next to your alerts and assets: FFTs, control charts and high-rate signals that generic dashboards struggle with.

Compared with the alternatives

Capability	Build in-house	Embedded Grafana	Chart libraries	Kymoscope SDK
Time to a working analysis view	Months	Days	Weeks	Hours
High-rate signals and linked zoom	You build it	Limited	Chart only	Built in
Files of hundreds of MB, client-side	You build it	Needs a database	No	DuckDB-WASM
End-to-end encrypted live data	You build it	No	No	Built in
Math channels for end users	You build it	Query language	No	Built in
Your data stays on your servers	Yes	Self-hosted: yes	Yes	Yes

Questions teams ask first

Does our data go through Kymoscope?

No. Datasets and workspaces move between your backend and your users’ browsers. Live streams cross the Kymoscope relay as ciphertext; the password that decrypts them never leaves the viewer.

Which frameworks are supported?

Any. The engine has no UI and charts mount into any element. React apps get bindings from @kymoscope/sdk/react; pages without a bundler use the standalone script, which carries its own React.

Is this the Kymoscope app in an iframe?

No. The Kymoscope app is our finished UI. The SDK is the engine underneath it (imports, laps, worksheets, charts, math channels, live streams), and you build your own buttons, menus and layout around it.

What file formats can users open?

Delimited text (CSV, TSV, .dat, with delimiter, decimal-comma and units-row detection) and binary measurement files: MF4/MDF with DBC-decoded CAN, EDF/BDF, XDF, TDMS, HDF5, MAT and COMTRADE, in memory or out of core, in the browser. You can also hand the SDK numeric arrays from any format you already parse.

What happens without a license key?

Everything works, with a small “Powered by Kymoscope” badge in the corner of each chart. Production use requires a key for each domain; evaluation does not.

Can we restrict features per plan?

Yes. Limits cover charts per worksheet, channels per chart, worksheets, math channels and workspace import/export. When a user hits one, the engine emits a limit event and you decide what to show.

How do our users get live data without Kymoscope accounts?

Your backend mints a watch ticket with your API key and passes it to the browser. It is valid for one stream, for two minutes, for watching only, and the SDK renews it while the stream is open.

Put engineering charts in your product this week

The quickstart takes five minutes. You can evaluate without a license key.

Read the quickstart Contact sales

The engine behind Kymoscope,under your own UI.