Graph Editor

Anatomy

A node has a header (name + an operator glyph where relevant), input sockets down the left edge, and output sockets down the right. Each socket has a type, shown by its colour. Drag from an output to an input to wire them — types must be compatible. A thin top stripe marks the node's category.

in a value the node consumes · out a value it produces · display widgets are sinks (inputs only).

Input

The single source of live sim data. Outputs one socket per telemetry channel — the full iRacing v5 feed: engine & fluids, per-wheel tyres (temp / wear / pressure), suspension & dampers, attitude, force feedback, weather, lap & timing, flags & session state, standings, pit & strategy, push-to-pass and more — 228 channels grouped into collapsible categories — collapsed by default, with a search box at the top to filter by name. There's exactly one Input per graph.

It also exposes the whole multi-car field as a green cars table output (in the Race category) — one row per car: position, class position, name, number, class, pit status, and two ready-made gaps: gap_to_leader_s (to the leader of that car's class — correct in multi-class racing, so a GT3 isn't timed against an LMP) and gap_to_ego_s (signed, to your car). For a standings, wire it straight into a Table Row (sort by position, display gap_to_leader_s). For a relative, route it through a Focus first (pivot on is_player, sort by gap_to_ego_s).

ref see every channel, its format and meaning in the Channel reference

out every telemetry channel (+ your math channels) · cars (table)

Mock Telemetry editable

A design-time control surface that feeds the Input node while you build — so your gauges come alive without a live session. Same categorised, searchable channel picker as Input, but each row is a setter instead of an output. It has no sockets: it writes the mock feed the Input node reads.

Manual — set any channel by hand (slider + field for numbers & booleans, a text box for strings like track or driver name). Play — load a real lap or an .ibt file and scrub / loop it to animate every channel at once. Presets — save & reload named setups, reusable across dashboards.

Game selector — Any / iRacing / AC. Pick the sim you're building for and the mock behaves like its connector: channels that game doesn't provide are greyed out (“not sent”) and your dashboard receives the real wire value — 0 or empty — exactly as it would live. Channels marked with a ⚠ warning are approximations on that game (hover for the detail). Applies to Manual and Play, so replaying an iRacing lap with AC selected shows what an AC session would look like. iRacing provides every channel; Any lifts all restrictions.

out nothing wired — it drives the editor preview via the Input node

Const: Number · Bool · String · Color editable

A fixed value you type into the node — a number, a true/false toggle, a text string, or a colour from a picker. Use them as thresholds, labels, fallbacks, and tints (the 5000 max in the quick start is a Number const).

out the constant (number / boolean / string / color)

Vec2: Make · Split · Const vector

Make Vec2 packs two numbers into a vector; Split Vec2 unpacks one back into x/y; Const Vec2 is a fixed vector you edit inline. Vectors carry 2-D things like position or size.

Make x,y → out (vector) · Split in (vector) → x,y · Const → out (vector)

Transform editable

A position/rotation/scale source. Outputs x, y, rotation, scaleX, scaleY and a normalized anchor (9 presets). Wire it into an asset to place or scale the whole widget.

out x, y, rotation, scaleX, scaleY, anchorX, anchorY (number)

Focus editable

A generic window-around-a-pivot transform: table in → table out (same columns). It sorts the table, finds the pivot row, and returns 2·window+1 rows centred on it. This is how you build a relative — but it's generic (works on any table: the sectors around the active sector, etc.).

• on (pivot) — the boolean column that marks the row to centre on. For a relative: is_player (your car).
• sort by + ↑/↓ — the column that orders the window. For a relative: gap_to_ego_s, descending (ahead on top).
• window — how many rows each side of the pivot.

Edges: the pivot is always the middle row. If it's near the top or bottom of the field (you're leading, or last), the missing side is filled with blank rows — Focus never wraps around to the other end. Pivot not found in the table → all blank.

Feed the output into a Table Row inside a ForEach (count = 2·window+1) to render each row.

in table (table) · out table (same columns, windowed)

Table Row editable

The workhorse of the table nodes. It takes a table (from Input's cars, or a Focus), optionally sorts it, picks the row at index, and exposes one output socket per column — each typed to match. Wire the column you want straight into a display.

• index — the row to pick (0 = first after sorting). Set it in Properties for a fixed row, or wire the index socket (e.g. from a ForEach) — the wire wins when connected.
• sort by — a dropdown of the connected table's columns (or (unsorted) for its natural order), plus an ↑/↓ direction.
• The output sockets appear automatically once a table is connected — they mirror that table's schema. Connect nothing and the node shows “Connect a table”.

To render a full table, drop Table Row inside a ForEach block and wire the loop index in — each iteration is one row. The number of rows is just the ForEach count — wire a constant (e.g. 10 for a top-10), and offset each row's Y by index × rowHeight.

in table (table) · index (number) · out one socket per column of the upstream table, typed per column

Math operator-select

Arithmetic on two numbers. Choose the operation from the node's op dropdown:

• + add — in1 + in2
• − sub — in1 − in2
• × mul — in1 × in2
• ÷ div — in1 ÷ in2 (÷ 0 → 0)
• % mod — remainder of in1 ÷ in2 (% 0 → 0)
• ^ pow — in1 raised to the power in2

in in1, in2 · out out (number)

Trig (cos / sin) operator-select

Trigonometric function of an angle in radians. Choose via the op dropdown:

• cos — cosine, output in [−1, 1]
• sin — sine, output in [−1, 1]

in in (radians) · out out (number)

min / max (extremum) operator-select

The smaller or larger of two numbers. Choose via the op dropdown:

• min — the smaller of in1, in2
• max — the larger of in1, in2

in in1, in2 · out out (number)

round / floor / ceil (rounding) operator-select

Convert a number to a whole integer. Choose via the op dropdown:

• round — nearest integer (halves go up)
• floor — round down, toward −∞
• ceil — round up, toward +∞

in in · out out (number)

Clamp

Constrains a value to stay within [min, max].

in in, min, max · out out

Abs · Sqrt

Abs gives the magnitude (drops the sign); Sqrt the square root (negatives clamp to 0).

in in · out out

Lerp

Linear interpolation between a and b by t (clamped 0–1). t=0 → a, t=1 → b.

in a, b, t · out out

Remap

Rescales a value from one range to another — e.g. RPM 0–8000 into 0–1, or a pedal 0–1 into 0–100%.

in in, fromMin, fromMax, toMin, toMax · out out

Lerp Color

Blends two colours by t — a smooth two-colour crossfade.

in a, b (color), t (number) · out out (color)

Ramp Color editable

Maps a 0–1 input through an editable multi-stop gradient — perfect for RPM shift lights or a temperature scale. Add/move colour stops inline. The blend between stops is set by a dropdown:

• block — hard steps, no blend (each stop's colour holds until the next)
• linear — straight RGB blend between adjacent stops
• perceptual — blends in OKLab so mid-tones stay vivid (no grey dip)
• smooth — linear blend eased at each stop (smoothstep)
• cubic — one smooth curve through all stops, no corners

in t (0–1) + per-stop offset/color · out out (color)

Format Time

Turns a number of seconds into a readable time string. Pick the format from the mode dropdown (a live preview shows the result):

• MM:SS.mmm — lap time, e.g. 1:23.456
• SS.mmm — seconds only, e.g. 23.456 (sectors)
• H:MM:SS — race / session time, e.g. 1:23:45
• ±SS.mmm — signed delta, e.g. +0.567 / −1.234 (gaps)

in input (seconds) · out out (string)

Expression editable

A mini wrangler — a small program over telemetry, powerful enough to replace most node chains on its own. Write one or more statements separated by ;, and the node grows the sockets it needs:

• Bare names become input sockets — rpm / rpmMax adds ports rpm and rpmMax.
• name = … is a local (no socket): ratio = rpm / rpmMax;
• @channel reads telemetry directly, no wire: @gear, @speed_kmh.
• $name = … adds a named output: $shift = ratio > 0.95. Outputs exist only through $ — a program with no $ has no output socket (the node shows a hint instead).
• Components read & write vectors (.x .y) and colours (.r .g .b .a, 0–255): $dir.x = vel.x * 2.
• Whole colours & text: $c = mixcolor(a, b, t) makes a colour output, $label = "P" + str(@position) a text output.
• State & time: prev, rising, pulse, blink, elapsed… let one expression do what the Changed / Pulse / Blink nodes do.

The editor has live syntax colouring and autocomplete (functions, PI/E, and @channels). Full grammar, every function with an example, recipes and colour key on the expression language page (searchable by category) — also one click away from the node's Properties panel.

in one socket per bare variable (number / vector / colour) · out one per $name (number / vector / colour / text)

Logic operator-select

Boolean algebra and numeric comparisons in one node — choose the operation from the op dropdown. The output is always a boolean; the inputs adapt to the operator.

Boolean ops — boolean inputs:

• && and — true when both inputs are true
• || or — true when at least one input is true
• ! not — inverts a single input (one socket: in)

Comparisons — number inputs:

• == eq — equal · != neq — not equal
• < lt — less than · <= lte — less or equal
• > gt — greater than · >= gte — greater or equal

in in1, in2 (just in for !) · out out (boolean)

If

Branches between two values by a condition: outputs then when true, otherwise else. Polymorphic — pick the value type (Number, String, Boolean, Color, Vector) in Properties, or just wire then/else and the sockets adapt. Replaces the old If Color node.

in cond (boolean), then, else (value type) · out out (value type)

Switch editable

Maps a number to a string via a list of cases — e.g. gear 0→"R" 1→"N" 2→"1"…. Emits the fallback if no case matches.

in input (number), fallback (string) · out out (string)

ForEach block

Repeats the nodes inside the block once per iteration — e.g. a row of N shift-light LEDs from one network. Drops a begin node (giving index and count) and an end marker.

in count · out index, count (number, on the begin node)

Changed operator-select

Fires true for exactly one frame when the input changes — the event detector. Pick the edge from the op dropdown:

• rising — the value went up (a boolean turning on counts: 0 → 1)
• falling — the value went down
• any — any change, either direction

Booleans are accepted directly (off = 0, on = 1). Typical use: feed a Pulse to stretch the one-frame event into a visible reaction.

in in (number or boolean) · out out (boolean, 1 frame)

Pulse

When trigger turns on, the output stays true for duration seconds, then drops back. Triggering again while the pulse is running restarts the timer (the reaction is prolonged).

in trigger (boolean), duration (seconds, default 5) · out out (boolean)

Blink

A square wave: alternates true/false at freq Hz while enable is on. duty (0–1) is the fraction of each period spent ON. When disabled the output is false and the phase resets, so re-enabling always starts ON.

Wire out straight into a display's opacity to make it flash (booleans coerce to 1/0 on number slots).

in enable (boolean, default on), freq (Hz, default 2), duty (0–1, default 0.5) · out out (boolean)

Text

A text label. Its value is polymorphic — wire a number, string, etc., and format it (number, time) in Properties. The Style section offers a 25-font library (racing display, futurist, LCD, sans, mono) plus "Import font…" to load your own .ttf / .otf / .woff / .woff2 — imported fonts are embedded in the .slxd, so the dashboard renders identically on any machine.

in value (any), fillColor (color), effects

Rect

A rectangle — solid or with a linear gradient and strokes. Great as a backdrop, panel, or status block.

in fillColor or gradient stops, stroke width/color, effects

Ellipse

A circle, ellipse, arc or ring. Same wirable fill as the Rect (solid fillColor, or gradient angle + per-stop sockets), plus Figma-style arc controls: start (degrees, 0 = 3 o'clock, clockwise), sweep (degrees, 0–360) and ratio (inner radius 0–1 — a ring when > 0). Wire sweep from a 0–360 value and you have a circular gauge; add ratio for a donut. Strokes and effects are wirable like the Rect (inside/outside strokes fall back to center on an arc).

in fillColor or gradient stops, start / sweep / ratio, stroke width/color, effects

Image

An image — a logo, car silhouette, or custom gauge face. Source and scale set in Properties. The node can also hold an image set: add more images ("+ Add" on the node or in Properties — the picker accepts multiple files at once) and an index socket appears — wire a number to pick which image shows (floored and clamped to 0…N−1). Perfect for flags, gear states or weather icons driven by telemetry; one image visible at a time.

in index (number, with an image set), opacity (number), effects

Track map

Draws a map of the circuit. It auto-records the racing line from the car's GPS (lat / lon) as you drive — SimHub-style — then renders that outline. On top of the trace it plots live car positions as dots: your car and the other cars, each placed along the recorded line. Add an optional start / finish line and per-car labels. Before a trace exists it shows a dashed placeholder.

The trace records itself the first time you run a clean lap on track (out-laps and the garage are ignored), and is saved with the dashboard — one shape per circuit. It needs GPS channels: iRacing provides them ; Assetto Corsa does not yet feed lat / lon, so the trace won't record there.

Everything below is in the Properties panel, grouped into collapsible sections:

• Trace — the circuit line's colour and width.
• Your car — toggle the marker, set its colour and size.
• Other cars — toggle them, set size, and either a single colour or Colour by class (a cycled palette, one hue per class present — for multi-class fields).
• Labels — draw a text label on each dot, taken from a wired table column (Input's cars or a Focus), matched by car_number. Pick the column and a text colour.
• Start / finish — toggle the line and set its colour.

The Track map sockets block on the node exposes the markers + start/finish params as wirable inputs (show / colour / size for your car & others, colour-by-class, start-finish colour), alongside the trace strokeColor / strokeWidth and the labels table. A wired socket wins over its Properties value — so you can drive e.g. your car's colour from a flag, or pulse its size.

in trace (strokeColor, strokeWidth) · car markers (your car + others: show / colour / size, colour-by-class) · labels (table, joined by car_number) · start/finish colour · transform (x, y, rotation, scale, anchor) · no outputs (draws on the canvas)

Table

Renders a whole table in one widget. Wire a table — Input's cars, or the output of a Focus — and it draws the full grid: header + one row per record. This is the one-node alternative to laying out many Table Rows + Text widgets by hand. Unwired, it shows a dashed placeholder.

Everything below is in the Properties panel:

• Header — show / hide the column-name row.
• Row height, Size, Text & Header colour — the base look. Columns split the widget width evenly; numbers align right, everything else left.
• Row lines / Col lines — separators, with a shared colour + width. Padding insets the cell text.
• Columns — tick which columns to show and reorder them ↑/↓ (from the connected table's schema); All resets to every column.

The Style sockets block on the node exposes most of these as wirable inputs — header on/off, row/cell sizes, text & header colour, separators and outer border. A wired socket wins over its Properties value, so you can drive e.g. a border colour from a state. Columns, conditional formatting, alignment and font stay in Properties (no socket).

Conditional formatting formulas

Add rules to colour cells from the data — like a spreadsheet. Each rule is an Expr formula evaluated per record; when it's true, the rule's style applies. Pick a target (the Whole row, or one column) and set a background, text colour and/or bold. Rules stack — later ones win.

• car_class == 3 · target car_class · background red — flag the GT3 class.
• is_player == 1 · target Whole row · highlight — your own row.
• gap_to_ego_s > 25 and car_class != 3 · target name · blue text — a backmarker, computed on the fly (no extra column needed).

Formulas see the table's numeric and boolean columns as variables (booleans read as 1 / 0). A formula that doesn't parse simply doesn't fire, so a half-typed rule is harmless.

in table (table) · Style sockets (header, row height, cell padding, font size, text/header colour, row/column lines + colour/width, outer border + colour/width) · no outputs (draws on the canvas)

Asset instance

A reusable widget — a packaged sub-network with typed inputs and outputs (like a function or component). Make one by selecting nodes and pressing Ctrl+G, or drop a built-in (like Bar or Shift Lights Row) from the +Assets chip. Assets can nest, and each instance can override inputs and styling.

in the asset's inputs + transform (x, y, rotation, scale, anchor) · out the asset's outputs

Subgraph Inputs & Outputs

Found inside an asset's body: Inputs exposes the asset's parameters as outputs to wire from; Outputs collects its results. Created automatically — you don't add them from the menu.

Inputs → out per parameter · Outputs ← in per result

Note · Frame

Documentation, not computation. A Note is a free-floating text label; a Frame is a titled box that groups nodes and moves them together. Neither affects the result — they keep a graph tidy.

no inputs · no outputs · visual only