Unified mission control and data review for hardware operations

Next generation engineering teams build and operate the world's most advanced hardware using Synnax. One platform for real-time data acquisition, hardware control, visualization, and analysis.

New

Arc, the modern standard for writing automations

Learn More ->
Synnax Console

See everything, control anything

Build real-time dashboards, plot live telemetry, and command your hardware from a single, unified console.

2.1 -> Schematics

Your system, at a glance

Build interactive schematics that reflect live system state. Drag valves, sensors, and actuators onto a canvas and bind them directly to your hardware channels. No programming required.
Learn More →
2.2 -> Line Plots

Millions of points, zero lag

Plot millions of points of live and historical telemetry with sub-millisecond precision. Pan, zoom, and annotate without dropping a frame.
Learn More →
Line Plot
Measure
Line plot measurement detail showing slope, delta X, and delta Y

Close the loop on hardware automation

Synnax unifies test automation and production control into a single platform. Write reactive sequences, deploy to real-time hardware, and transition between automated and manual operation seamlessly.

3.1 -> The Arc Language

Write sequences, not boilerplate

Arc is a reactive programming language purpose-built for hardware automation. Define control sequences, manage authority, and orchestrate your entire system in a few lines of code.
Learn More →
sequence main {
    stage press {
        1 -> press_vlv_cmd,
        press_pt > 500 => maintain
    }
    stage maintain {
        0 -> press_vlv_cmd,
        wait{duration=5s} => vent
    }
    stage vent {
        1 -> vent_vlv_cmd,
        press_pt < 10 => complete
    }
    stage complete {
        0 -> vent_vlv_cmd,
        0 -> press_vlv_cmd
    }
}
Press Valve0.0 psiVent Valvemain
3.2 -> Production Ready

Built for the Systems That Matter Most

Arc eliminates the most common sources of automation failures. Develop on your laptop, deploy to real-time hardware, and think in procedures, not programs.

Predictable Execution

Auto 0Auto 1Auto 2
Every cycle runs the same way, every time. Consistent behavior from bench test to production at rates up to 5 kHz.

Seamless Control Handoff

automatedabortmanual
Operators take manual control without interrupting automation. Emergency overrides take priority instantly.

Understand what happened, and why

Review test data, compare runs side-by-side, and drill into anomalies without ever leaving the platform.

4.1 -> Storage Engine

The only deeply integrated control system and database engine

Permanently store and organize kilohertz-rate data from thousands of channels with read and write speeds exceeding 10 million samples per second.
See the benchmarks →
press_pt_001
1 kHz float64 3.2M
tc_inlet_temp
100 Hz float32 890K
flow_valve_cmd
500 Hz uint8 1.1M
load_cell_z
5 kHz float64 12.8M
accel_x
2 kHz float32 6.4M
strain_gauge_03
1 kHz float64 2.9M
vent_vlv_state
250 Hz uint8 540K
chamber_press
10 kHz float64 28.1M
ox_tank_level
100 Hz float32 720K
igniter_cmd
500 Hz uint8 1.4M
thrust_main
5 kHz float64 15.6M
fuel_temp_02
200 Hz float32 1.1M
gps_lat
10 Hz float64 42K
servo_pos_y
1 kHz float32 3.0M
batt_voltage
50 Hz float32 180K
imu_gyro_z
2 kHz float64 7.2M
rcs_valve_04
500 Hz uint8 1.5M
cabin_press
100 Hz float32 620K
motor_rpm
1 kHz float64 4.1M
helium_reg_press
250 Hz float64 980K
pyrometer_01
500 Hz float64 1.8M
tank_press_ox
1 kHz float32 3.5M
tvc_pitch_cmd
2 kHz float32 5.8M
prop_flow_rate
500 Hz float64 2.1M
vibration_rms
4 kHz float32 9.6M
ox_injector_t
200 Hz float64 1.3M
gn2_reg_press
1 kHz float64 3.8M
4.2 -> Organize with Ranges

Name it, tag it, find it later

Mark test runs, events, and anomalies as named time ranges. Attach metadata, label and nest them into hierarchies, and build an audit trail that makes every data point traceable.
Learn about ranges →
Explorer
Range explorer showing labeled test runs with stage indicators
Range
Range detail panel showing metadata, labels, and hierarchy

Process data at the speed it arrives

Build real-time data pipelines that transform, aggregate, and alert on live telemetry. No infrastructure to deploy.

5.1 -> Calculated Channels

Sensor voting in 10 lines, not 10 services

Attach Arc expressions to channels and Synnax evaluates them on every sample, whether live or historical. Stateful variables, vector math, and reactive execution replace entire processing pipelines.
Learn More →
fahrenheit := celsius * 9 / 5 + 32
return fahrenheit
celsius

22.3 °C

× 9/5 + 32

 

fahrenheit

 

5.2 -> Alarms

Define alarms visually, monitor everything at a glance

Build alarm logic with a visual node editor. Wire sources, conditions, and actions together without writing code. A unified status bar surfaces every alarm, device, and system health indicator in one place.
Learn More →
Alarm Editor
Visual Arc alarm editor showing a node graph with source, constant, comparison, stable-for, and change-status nodes

Plug in your hardware, start streaming

Synnax ships with native drivers for the most popular data acquisition and control hardware, and a setup workflow that gets you from unboxing to streaming in minutes.

6.1 -> Supported Hardware

Works with your
existing
hardware

Native drivers for industry-standard protocols and vendors. If your device speaks OPC UA, Modbus, or EtherCAT, Synnax connects to it out of the box.
+ Custom
6.2 -> Getting Started

Streaming in three steps

Connect your hardware, configure your channels, and start acquiring data. No custom driver code, no middleware, no separate data historian.
Attach device
Configure instrumentation
Acquire data and control

Build on the platform

Use Synnax as a framework to build advanced industrial systems. Connect AI models, embed real-time processing, and interface with external controllers through native client libraries in Python, TypeScript, and C++.

hardware_daq
NI · LabJack
ext_ecu
C++ embedded
custom_io
Modbus · serial
ml_pipeline
Python
dashboard
TypeScript
test_runner
CI/CD
Stream
import synnax as sy

client = sy.Synnax()

with client.open_streamer(
    ["temperature", "pressure"],
) as s:
    for frame in s:
        print(frame)
Write
import synnax as sy

client = sy.Synnax()

with client.open_writer(
    sy.TimeStamp.now(),
    ["time", "sensor"],
) as w:
    w.write({
        "time": sy.TimeStamp.now(),
        "sensor": 25.3,
    })
    w.commit()
Read
import synnax as sy

client = sy.Synnax()

data = client.read(
    sy.TimeRange(start, end),
    ["temperature", "pressure"],
)
print(data.to_df())
8 -> Get In Touch

Let's talk about your project

Request a demo, get detailed pricing, or ask us anything. We'll get back to you within 24 hours.
info@synnaxlabs.com

Thanks for reaching out!

We'll be in contact within 24 hours.