Introduction to Arc

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

Arc is Synnax’s automation language for hardware control. Rather than relying on polling loops, you declare what happens when a data channel changes. For complex procedures like engine startup, fridge cooldown, or calibration sweeps, you compose reactive flows into sequences and stages.

This reactive model is particularly useful for:

• Procedures where you progress through linear steps and parallel states based on conditions
• Safety monitoring where multiple conditions must be checked simultaneously
• Notifications where fault conditions trigger external pages, emails, or on-screen alerts
• Data transformations where sensor values need scaling or filtering
• Automated reporting where computed metrics, pass/fail signals, or event markers feed dashboards and post-test reviews

How Arc is Different

Consider a safety check that triggers an abort when tank pressure exceeds 50.

A Python approach might look like:

with synnax.open_streamer(["tank_pressure"]) as streamer:
  with synnax.open_writer(
    channels=["abort_cmd"],
  ) as writer:
    while True:
        frame = streamer.read()
        pressure = frame.channels["tank_pressure"]
        if pressure > 50:
            writer.write({"abort_cmd": 1})
            break

This gives you full control: every detail of the automation is yours to define. The tradeoff is that you’re writing the engine yourself. Streaming, writes, timing, and stop conditions all live in code you maintain. Synnax provides a high-speed streaming client for the I/O (most competing platforms don’t ship one at all), but the rest is the cost of any complex Python automation: structure, concurrency, error handling, all growing with the script.

A table-based automation tool might look like:

A tabular row hides the implementation. The columns capture what to check and when, but everything else is defined by engine: whether the check on frame spans 29.9-30.0 or 30.0-30.1, which sample the check reads (latest? averaged?), how dropped samples are handled, underlying loop rate. Configuration spreads across multiple tables (a checks table here, a nominal sequence table elsewhere), and timing rows don’t always line up.

In Arc, the same check is one line:

tank_pressure > 50 => abort_sequence

When tank_pressure updates, Arc evaluates the check. No loops, no polling, and no timing scaffolding required. You declare the check exactly as you need it.

Who Arc is For

Arc is designed for engineers working with hardware telemetry 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
• Python scripts for hardware automation: Arc replaces polling loops, streamers, and timing code with declarative reactive flows
• Manual control through Synnax schematics: Arc automates the button clicks and valve toggles you’ve been doing by hand
• Data consolidation, analysis, and dashboards: Arc enables real-time computation of metrics and pass/fail signals for post-processing and live dashboards

You don’t need to be a software developer. If you understand your system, you already know what to automate. Arc makes the how painless.

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.

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.