Z+

The native language of Zeos. Describe connections, not procedures. The OS resolves them.

Documentation Full Spec Playground All 27 Programs

Operators

→

flowSignal flows from left to right

~>

tapObserve without affecting (read-only)

-x>

severCut a wire (disconnect, block)

<->

exchangeBidirectional — request/response

@

pinRun on specific hardware

|

mergeMultiple signals converge

{}

forkOne signal splits to multiple paths

Logic

gate()

gateSignal passes or doesn't. The universal filter.

knee:

kneeSmooth transition zone. No hard cutoff. No oscillation.

delta()

deltaRate of change. t minus t-1. The language's soul.

resonance

resonanceIndependent signals converging = certainty.

grade

gradeContinuous health score 0.0 to 1.0. Not boolean.

Time

t, t-1, t-2

temporalCurrent value, previous, history. Not a library. Keywords.

on_silence

silenceAbsence of signal IS data. Graded by duration.

sustained:

sustainedGate must hold for duration. Ignores momentary blips.

within()

confluenceSignals must arrive within time window.

then

sequenceA then B — ordered temporal coincidence.

baseline()

baselineRolling learned normal. What's typical over time.

decay()

decaySignal strength decreases over time.

Examples

Hello World

A sensor wired to a motor through a gate.

sonar : gpio(17) -> distance @ cm

sonar -> gate(> 20cm) -> motor

// that's the program. the robot avoids walls.

Self-Healing Fleet

A fleet of accelerator cards that sort, route, and heal themselves.

fleet : pcie.discover(type: accelerator) -> cards

cards -> { telemetry.thermal, telemetry.timing, history.errors }
     -> grade : weighted(thermal: 0.3, timing: 0.25, errors: 0.1)

grade -> gate(> 0.9) -> tier_prime
grade -> gate(0.3 ~ 0.6) -> tier_light
grade -> gate(<= 0.3) -> tier_rest    // benched. healing.

// watchdog
cards.thermal -> gate(> 72C, knee: 5C) -> route.bias(card, -0.2)
cards -> on_silence(> 5s) -> triage.bench(card)

Anomaly Detection

Learn normal, detect deviation, correlate across signals.

cpu -> baseline(window: 7d) -> cpu_normal
cpu -> deviation(from: cpu_normal) -> gate(> 2σ, knee: 1σ) -> anomaly(cpu)

memory -> baseline(window: 7d) -> mem_normal
memory -> deviation(from: mem_normal) -> gate(> 2σ) -> anomaly(memory)

// resonance — multiple anomalies = real incident
anomaly(cpu)    -> |
anomaly(memory) -> | resonance(2 of 3, within: 5m) | -> incident(warn)
anomaly(disk)   -> |

Knee — Smooth Control

No oscillation. No bang-bang. The gate fades smoothly.

// hard gate: off at 71°F, on at 72°F (oscillates)
temp -> gate(< 72F) -> heater

// knee gate: fades from 69°F to 72°F (smooth)
temp -> gate(< 72F, knee: 3F) -> heater

// PID control is three Z+ constructs:
// P = knee (proportional response)
// D = delta (rate of change dampening)
// I = baseline deviation (accumulated error)

What doesn't exist

VariablesSignals flow. State is t. History is t-1.

FunctionsNodes exist continuously. They don't run once.

LoopsSignal chains resolve continuously.

ThreadsConcurrency is structural.

ExceptionsChains degrade gracefully. on_silence, not try/catch.

ImportsThe OS knows everything at boot.

ClassesSignals have structure. That's it.

NullSilence is the absence of signal. It's data.

Package manager.zp files compose by connecting, not importing.

Build systemThe compiler reads .zp files. No config.