The BLE workbench,
reimagined for Mac.

Entry point of the workflow. Exactly one Start node is allowed — execution begins here when you press Run.

Terminates a branch cleanly. Optional — branches that reach a dead end also stop, but End makes the intent explicit.

Parks the current branch indefinitely. The workflow stays in the running state until the user hits Stop, so concurrent triggers (timer, on-notification, on-device-discovered) can keep firing. Has no outgoing edges.

Blocks until a peripheral advertisement matches the configured filters (name substring, manufacturer-data hex prefix, RSSI threshold). Auto-starts a scan unless disabled.

Blocks until a connect event fires. Optionally filters by mac so the trigger only resumes when a specific device comes online.

Blocks until a disconnect event fires. Used to react to peripherals dropping the link without polling.

Blocks until a characteristic notification matches the optional hex prefix. Auto-subscribes to the characteristic before listening so a separate Subscribe step isn't required.

Waits on a time condition before continuing. After delay = one-shot wait. Interval = self-looping periodic tick that runs forever until stopped. Exact date = wait until an ISO-8601 timestamp.

Cancels a running Timer node addressed by name. The targeted timer's pending wait is disposed immediately, no more ticks fire. Other branches and timers keep running.

Waits for the next advertisement matching the configured filter (mac, name substring, manufacturer prefix) and stashes selected fields into prefixed variables. One-shot — returns as soon as a match arrives.

Begins a BLE scan. Continues running asynchronously; subsequent steps execute immediately without waiting for results.

Stops an in-progress scan. Pair with Start Scan when you want a bounded discovery window.

Connects to a peripheral by MAC. Resolves on "connected" — i.e. CoreBluetooth fired didConnect and the link is up.

Closes the active connection. Always good practice at the end of a workflow so the peripheral is free for other apps.

Asks the peripheral to enumerate its services. Required before reading/writing characteristics on most devices.

Enumerates the characteristics under each discovered service. Run after Discover Services.

Enables notifications/indications on a characteristic. Subsequent notifications populate lastReadHex and fire Wait Notification steps.

Turns off notifications for a characteristic. Useful when a workflow has multiple subscribe/unsubscribe phases.

Reads the current value of a characteristic. Resolves with raw bytes; the bytes are stored in lastReadHex and (optionally) into a named variable.

Writes bytes to a characteristic. Supports hex (DE AD) or text payloads, and chooses write-with/without-response automatically based on the characteristic's properties.

Reads the current RSSI of the active connection. Stored in the lastRSSI runtime slot and (optionally) into a named variable.

Reads the negotiated ATT MTU. macOS CoreBluetooth doesn't expose an API to request a specific MTU — this step just surfaces what the OS negotiated at connect time.

Reads a GATT descriptor (e.g. Characteristic User Description 0x2901, Format 0x2904, or the current notify-state bits in the CCCD 0x2902).

Writes bytes to a writable GATT descriptor. ⚠️ macOS blocks writes to the CCCD (0x2902) — use Subscribe instead. Useful for the rare devices that expose other writable descriptors.

Loops its first output edge N times, then takes the second output (exit) once. Body executions are numbered (#1, #2, …) in the run log.

Pauses the branch for a fixed duration. Other parallel branches keep running.

Fans out into multiple branches that run concurrently. Each outgoing edge starts its own execution token.

Counterpart to Parallel: waits until every incoming edge has delivered a token before continuing downstream.

Wraps its protected branch (edge 0). If any downstream step on that branch fails, execution jumps to the catch branch (edge 1) instead of failing the workflow.

Wraps a branch in a retry loop. If anything downstream of edge 0 errors, the executor delays then re-enters edge 0 — up to attempts total tries before falling through to edge 1 (the give-up branch).

Trailing-edge debounce for noisy streams. Waits for a quiet period before continuing; a fresh arrival within the window restarts the wait, so a burst of notifications collapses into a single downstream fire once the stream goes quiet.

Leading-edge rate limit. The first token through fires downstream immediately, then further tokens are dropped for the cooldown window. The prompt-response counterpart to Debounce — caps how often a path runs without waiting for the stream to go quiet.

Iterates an array variable, running the body edge once per element with the current item (and index) exposed as variables. Cleaner than Repeat + manual index arithmetic.

Branches on a condition. Edge 0 = true, edge 1 = false. Compares a Source (variable, last RSSI, last hex, isConnected) against a Right-hand value using the chosen operator.

Blocks the branch until a notification arrives on the characteristic, or the timeout elapses. The received bytes populate lastReadHex.

Checks a condition and fails the step if it's false. Same operand/operator semantics as the If node, but doesn't branch — it terminates the branch on failure (or jumps to the nearest Try/Catch / Retry catch edge).

N-way branch. Compares an input against one value per line and follows the matching outgoing edge. If nothing matches, the LAST outgoing edge fires as the default.

Stores a value into a named variable so later steps can reference it. The source can be a literal, another variable, last RSSI, last hex, or the connection state.

Converts a hex string into a decoded value (UInt8 / UInt16 / Float / UTF-8 / sliced bytes) or vice versa. Reads from lastReadHex if no input variable is set.

Parses a hex payload into multiple named fields in one node — replaces a chain of Transform nodes when you have a structured packet with several offsets.

Writes a free-form message into the run log. References to ${var} are resolved against the live variable store at run time, so the same node prints the current value of any variable wired upstream.

Evaluates an arithmetic expression and stores the numeric result. Only + − × ÷ and parentheses are allowed; variable references are spliced via ${var} before evaluation.

Increments (or resets) a named variable. Reads the existing value as a number, adds Delta, writes the new value back. An unset variable starts at 0.

Wall-clock measurement. Start records the current time against a named slot; Stop computes the elapsed milliseconds since the matching Start and (optionally) writes the value to a variable for downstream nodes.

Posts a notification to macOS Notification Center. First run prompts for permission; subsequent runs reuse the granted status. Title and body support ${var} substitution.

Computes a CRC checksum over a hex payload variable. Supports CRC-8, CRC-16/CCITT-FALSE, CRC-16/Modbus, and CRC-32 — the four shapes nearly every vendor BLE protocol uses for trailing checksum bytes.

Pulls a single value out of a JSON string by dotted path. Designed to consume the response body the HTTP node stores under its "Store as" variable without a Transform chain.

Generates a random integer in a range or a random hex byte string and stores it to a variable. Useful for jitter delays, payload fuzzing, and stress tests.

Converts between raw bytes and a Base64 string — encode bytes to Base64, or decode Base64 back to bytes. Saves the Transform-chain workaround for the Base64 payloads many BLE and REST APIs expect.

Extracts or sets a bit field within a value — the common "status byte packs several flags" shape of BLE protocols, without hand-rolling shift/mask arithmetic in an Expression node.

Sends an HTTP request to a URL with optional headers and body. Variables are interpolated with ${name}.

Appends a row to a CSV file on disk. Creates the file with the configured header on first run.

Writes a payload to disk in one shot (overwrites if exists). Use for snapshots, not append-style logs.