Introduction to Arc

What is Arc, who it's for, and when to use it

Arc is Synnax’s automation language for hardware control. If you’ve been using Synnax to acquire data and control hardware manually through schematics, Arc lets you automate those procedures.

Think of it as writing down the steps you would perform manually: open this valve when pressure reaches 500 psi, close it when temperature exceeds 300 degrees, then wait 30 seconds and move to the next step. Arc executes these procedures automatically while you monitor from the Console.

Who Arc is For

Arc is designed for test engineers and control system operators who understand what they want to accomplish but need a way to express it in code. If you’re coming from:

LabVIEW or visual programming tools: Arc’s syntax is more concise than block diagrams, and you don’t need deep programming experience to use it
PLC configuration (Rockwell, Siemens): Arc handles automation logic similar to function blocks, but integrated directly with Synnax telemetry
Manual control through Synnax schematics: Arc automates the button clicks and valve toggles you’ve been doing by hand

You don’t need to be a software developer. If you understand valves, pressure transducers, and control loops, you already know what to automate. Arc teaches you how to express it.

Graph Mode vs Text Mode

When you create an Arc automation, you choose between two editor modes:

Graph Mode

A visual, block-based editor where you drag and connect nodes. Good for:

Simple threshold alarms (“alert when pressure > 500”)
Basic on/off control
Quick prototyping without writing code
Users who prefer visual programming

Text Mode

A code editor where you write Arc syntax directly. Good for:

Multi-step test sequences with multiple stages
Complex logic with many conditions
Reusable functions across automations
Users comfortable with text-based configuration

Which should you use? Start with graph mode for simple automations. Move to text mode when you need sequences, stateful logic, or want more control over the automation structure.

This documentation focuses on text mode. Graph mode documentation is coming soon.

What Arc Does Differently

Unlike traditional programming where you write loops to poll sensors, Arc is reactive. You declare what should happen when data changes, and Arc handles the rest.

Instead of a traditional, Python-based approach:

with synnax.open_streamer(["tank_pressure"]) as streamer:
  with synnax.open_writer(["pressure_display"]) as writer:
    while True:
        frame = streamer.read()
        pressure = frame.channels["tank_pressure"]
        scaled = pressure * 2.0
        writer.write({"pressure_display": scaled})

You write:

tank_pressure * 2.0 -> pressure_display

Arc monitors tank_pressure for you. When it updates, the computation runs automatically. No loops, no polling, no timing code.

This reactive model is particularly useful for:

Test sequences where you progress through stages based on conditions
Safety monitoring where multiple conditions must be checked simultaneously
Data transformations where sensor values need scaling or filtering

Sequences

Most Arc programs are sequences: multi-step procedures that progress through stages based on conditions. Pressurization tests, startup routines, calibration procedures all follow this pattern.

sequence main {
    stage pressurize {
        1 -> valve_cmd,
        tank_pressure > 500 => next,
        abort_btn => abort
    }

    stage hold {
        1 -> valve_cmd,
        wait{duration=30s} => next
    }

    stage vent {
        0 -> valve_cmd,
        tank_pressure < 50 => complete
    }

    stage complete {
        0 -> valve_cmd
    }
}

sequence abort {
    stage safed {
        0 -> valve_cmd
    }
}

start_btn => main

Everything in a stage runs at the same time. In pressurize, Arc simultaneously keeps the valve open, monitors for target pressure, and watches for an abort. You don’t write loops or manage threads. You list what should happen, and Arc handles concurrency.

This matches how test procedures actually work. When pressurizing a tank, you hold a valve open while monitoring pressure while watching for abort conditions. Arc captures that parallelism directly.

Line order matters when multiple transitions could fire at once. Put safety conditions first so they take priority.

For the full guide, see Sequences and Stages.

Before You Start

Arc builds on Synnax concepts you likely already know:

Channels -> Arc reads from and writes to Synnax channels.
Drivers -> Arc automations run on a driver process.
Schematics -> Buttons in schematics can trigger Arc sequences.

If you’re unfamiliar with these concepts, revisit the above pages before continuing.

What’s Next

Ready to write your first automation? Continue to Get Started to create and run an Arc program in the Console.

Get Started