Node reference

ai 3 nodes

Node	What it is	Category	In	Out	Parameters
ai.complete stand-in	Ask a model and take its reply as text. In the editor page the loaded WebLLM answers; anywhere no published answer is waiting — every generated program among them — a local stand-in answers instead, rotating the prompt's words, and names itself flowrs-local.	AI	prompt	text, model	prompt:String, model:String, temperature:f64
ai.hybrid	Think, then answer, on the local decision loop.	AI	prompt, context, media, key	trace, text, source	prompt:String, question:String, options:String, levels:String, kind:enum, confirm:String, criteria:String, band:String, bundle:String, key:String, model:String, temperature:f64, threshold:f64
ai.object_detect	Find bright regions in an image and report each 4-connected region above luma 127 as a detection box, scored by its share of the frame.	AI/Vision	image	detections	—

audio 14 nodes

Node	What it is	Category	In	Out	Parameters
audio.gain	Apply a gain in decibels.	Audio/Process	audio	audio	db:f64
audio.load	Decode a 16-bit PCM WAV file to a sample buffer; any other file is refused, naming what it is.	Audio/Sources	—	audio	path:String
audio.mel	Mel-scaled spectrogram → a time×mel tensor.	Audio/Analysis	audio	mel	n_mels:i64, n_fft:i64, hop:i64, sample_rate:f64
audio.mfcc	Mel-frequency cepstral coefficients → a time×coeff feature tensor.	Audio/Analysis	audio	mfcc	n_mfcc:i64, n_mels:i64, n_fft:i64, hop:i64, sample_rate:f64
audio.mix	Mix two audio buffers into one, weighted by the balance parameter (0 is all a, 1 is all b).	Audio/Process	a, b	audio	balance:f64
audio.onset	Onset detection → the times (detections) where energy rises.	Audio/Analysis	audio	onsets	sensitivity:f64, n_fft:i64, hop:i64
audio.pitch	Fundamental-frequency (pitch) track → a per-frame signal.	Audio/Analysis	audio	f0	frame:i64, hop:i64, fmin:f64, fmax:f64, sample_rate:f64
audio.play stand-in	A buffer to the default output device — a stand-in at both tiers, not playback: the samples are checked (a non-finite one is refused) and counted, and nothing is heard.	Audio/Sinks	audio	—	—
audio.record stand-in	Audio from the default input device — a stand-in at both tiers, not a recording: a 1 kHz tone at -20 dBFS, seconds long. No microphone is opened.	Audio/Sources	—	audio	seconds:f64
audio.resample	Resample to a new sample rate.	Audio/Process	audio	audio	rate:i64, sample_rate:f64
audio.save	Write a sample buffer to a WAV file.	Audio/Sinks	audio	—	path:String
audio.spectrogram	Short-time Fourier transform magnitude → a time×frequency tensor.	Audio/Analysis	audio	spectrogram	n_fft:i64, hop:i64
audio.to_signal	Extract raw samples as a signal (the DSP bridge).	Audio/Bridge	audio	signal	—
audio.tone	Synthesise a test tone — the audio pillar's T0 source.	Audio/Sources	—	audio	waveform:enum, frequency:f64, amplitude:f64, duration_ms:f64, sample_rate:f64

capture 1 nodes

Node	What it is	Category	In	Out	Parameters
capture.open	Opens a logic or waveform capture from the browser's file store: VCD, FST, GHW, a sigrok session, or Saleae binary and CSV exports, detected by content.	Capture	—	capture, channels, sample_rate, duration, issues, summary	name:String, format:enum, sample_rate:f64

clock 1 nodes

Node	What it is	Category	In	Out	Parameters
clock.convert	Move a time from one clock domain to another — a board's monotonic timer to UTC, UTC to TAI — by adding an offset given as an input, so the offset is something measured and visible rather than assumed.	Units	time, offset	converted	from:enum, to:enum

cloud 7 nodes

Node	What it is	Category	In	Out	Parameters
cloud.particle.devices	List the devices a Particle token can see — the node builds the request and parses the reply wired back in. Nothing is sent at either tier; a driver performs the round trip.	Cloud/Particle	response	method, url, body, auth, devices, count, online, error	token:String, base_url:String
cloud.particle.event	Decode one Server-Sent-Events message from the Particle event stream.	Cloud/Particle	sse	method, url, auth, name, data, number, published_at, device_id, error	token:String, base_url:String, prefix:String
cloud.particle.function	Call a firmware function on a Particle device — the node builds the request and parses the reply wired back in. Nothing is sent at either tier; a driver performs the round trip.	Cloud/Particle	arg, response	method, url, body, auth, return_value, connected, error	token:String, base_url:String, device_id:String, function:String, arg:String
cloud.particle.publish	Publish an event to the Particle cloud — the node builds the request and parses the reply wired back in. Nothing is sent at either tier; a driver performs the round trip.	Cloud/Particle	data, response	method, url, body, auth, accepted, error	token:String, base_url:String, event_name:String, data:String, private:bool, ttl:i64
cloud.particle.variable	Read a firmware variable from a Particle device — the node builds the request and parses the reply wired back in. Nothing is sent at either tier; a driver performs the round trip.	Cloud/Particle	response	method, url, body, auth, value, number, error	token:String, base_url:String, device_id:String, variable:String
cloud.roboflow.detect	Run a hosted Roboflow model over a base64 image — the node builds the request and parses the reply wired back in. Nothing is sent at either tier; a driver performs the round trip.	Cloud/Vision	image_base64, response	url, body, content_type, detections, count, top_class, top_confidence, error	api_key:String, model:String, version:i64, confidence:f64, overlap:f64, format:enum
cloud.roboflow.parse	Turn a Roboflow response into detections.	Cloud/Vision	response	detections, count, top_class, top_confidence, error	min_confidence:f64

data 20 nodes

Node	What it is	Category	In	Out	Parameters
data.aggregate	Aggregate a column to a scalar.	Data	data	value	column:String, func:enum
data.cast	Cast a column to a dtype.	Data	data	casted	column:String, dtype:enum
data.csv.load	Load a CSV file into a DataFrame.	Data	—	data	path:String, header:bool, delimiter:String
data.csv.save export only	Save a DataFrame to a CSV file.	Data	data	—	path:String
data.dropna	Drop every row of a table that has a missing value.	Data	data	clean	—
data.fillna	Fill missing table cells with a literal value, the previous or next value in the column, or the column mean.	Data	data	filled	value:String, strategy:enum
data.filter	Filter rows by a boolean expression.	Data	data	filtered	condition:String
data.groupby	Group by a column and sum.	Data	data	grouped	by:String
data.join	Join two tables on a key column, as an inner, left, right or outer join.	Data	left, right	joined	on:String, how:enum
data.json.load	Load a JSON file into a DataFrame.	Data	—	data	path:String
data.json.save export only	Save a DataFrame to a JSON file.	Data	data	—	path:String
data.map	Apply an expression to a column.	Data	data	mapped	column:String, expr:String
data.melt	Melt (unpivot) to long form.	Data	data	melted	id_vars:String
data.pivot	Pivot a table: one row per index value, one column per distinct value of the columns field, filled from the values column.	Data	data	pivoted	index:String, columns:String, values:String
data.rename	Rename one column of a table.	Data	data	renamed	from:String, to:String
data.select	Keep only the named columns of a table (comma-separated).	Data	data	selected	columns:String
data.sort	Sort a table's rows by one column, ascending or descending.	Data	data	sorted	by:String, descending:bool
data.table	Register all data widgets into registry. An inline table — the DataFrame counterpart to image.test_pattern.	Data	—	data	csv:String
data.tdms	One TDMS channel as a signal.	Data	—	signal, count, sample_rate, unit, start_time_millis, source	name:String, group:String, channel:String
data.union	Vertically concatenate two DataFrames.	Data	top, bottom	combined	—

decode 10 nodes

Node	What it is	Category	In	Out	Parameters
decode.can	Decodes CAN 2.0 and CAN FD frames per ISO 11898-1, checking stuffing, CRC-15/17/21, the stuff count and the ACK, and following a bit-rate switch.	Protocol	capture	capture, values, text, count, errors, summary	channel:String, bitrate:f64, data_bitrate:f64, sample_point:f64, data_sample_point:f64, inverted:bool
decode.harp	Reads the bytes of the UART lane below it as Harp device messages — reads, writes and events with their register, type, timestamp and payload — skipping to the next frame over bytes that begin none, and reporting a bad checksum or a cut-off frame.	Protocol	capture	capture, values, text, count, errors, summary	—
decode.i2c	Decodes an I²C bus from its SCL and SDA lines: start, repeated start and stop, 7- and 10-bit addresses, ACK/NACK, with clock stretching and cut-short bytes reported.	Protocol	capture	capture, values, text, count, errors, summary	scl:String, sda:String, stretch_factor:f64
decode.i2s	Decodes I²S stereo PCM (Philips or left-justified) into left and right samples, taking the slot width from word select.	Protocol	capture	capture, values, text, count, errors, summary	sck:String, ws:String, sd:String, format:enum, word_bits:i64, signed:bool
decode.lines	Splits the characters of the UART lane below it into text lines, keeping damaged bytes in their line and flagging them, and marking an unterminated last line.	Protocol	capture	capture, values, text, count, errors, summary	terminator:enum
decode.onewire	Decodes a 1-Wire bus: resets and presence pulses, bytes, and the ROM commands with their ROM codes checked by CRC-8, following overdrive speed.	Protocol	capture	capture, values, text, count, errors, summary	channel:String, overdrive:bool
decode.pwm	Measures a PWM line period by period: duty cycle and frequency, with the partial periods at either end of the capture marked rather than measured.	Protocol	capture	capture, values, text, count, errors, summary	channel:String, polarity:enum
decode.registers	Reads the transfers of the I²C lane below it as register reads and writes, keeping an auto-incrementing register pointer per device.	Protocol	capture	capture, values, text, count, errors, summary	device:String, address_bytes:i64, byte_order:enum
decode.spi	Decodes SPI in any of its four clock modes, with or without chip select, MSB- or LSB-first, in words of 1 to 64 bits, reporting words cut short by chip select.	Protocol	capture	capture, values, text, count, errors, summary	clk:String, mosi:String, miso:String, cs:String, mode:enum, cs_polarity:enum, bit_order:enum, word_bits:i64
decode.uart	Decodes asynchronous serial (UART) on one line of a capture: data bits, parity, stop bits, inverted lines and auto-baud, with parity, framing, break and noise reported.	Protocol	capture	capture, values, text, count, errors, summary	channel:String, baud:f64, data_bits:i64, parity:enum, stop_bits:enum, bit_order:enum, inverted:bool, bits:bool

dsp 24 nodes

Node	What it is	Category	In	Out	Parameters
dsp.biquad	Biquad cascade over one frame, from rest: second-order sections in Direct Form II Transposed (scipy's sosfilt), designed by flowrs-dsp's IIR family (family, response, order, cutoff at sample_rate, ripple_db, stop_db) or written out (sections); every section is checked stable. The same f32 arithmetic in the browser, the Host program and on a microcontroller.	DSP	input	output	family:enum, response:enum, order:i64, cutoff:f64, sample_rate:f64, ripple_db:f64, stop_db:f64, sections:String
dsp.convolve	Convolve a signal with a kernel signal.	DSP	signal, kernel	output	—
dsp.decimate	Decimate a frame: every factor-th sample from the first (x[::factor]). No filter of its own, so a dsp.fir or dsp.biquad low-pass goes before it.	DSP	input	output	factor:i64
dsp.delay	Delay line with feedback.	DSP	input	output	delay_ms:f64, feedback:f64
dsp.detect_onsets	Attack times in a buffer, from [flowrs_dsp::detect_onsets].	DSP	samples	times, count	sample_rate:f64
dsp.envelope	ADSR envelope generator driven by a boolean gate, with attack, decay, sustain and release parameters.	DSP	gate	envelope	attack:f64, decay:f64, sustain:f64, release:f64
dsp.fft	Fourier transform of a signal frame, giving magnitude and phase spectra at the chosen size.	DSP	signal	magnitude, phase	size:enum
dsp.filter.bandpass	Band-pass filter a time signal around a center frequency with the given bandwidth.	DSP	input	output	center:f64, bandwidth:f64
dsp.filter.highpass	High-pass filter (one-pole).	DSP	input	output	cutoff:f64
dsp.filter.iir	IIR filter — the whole classic family (Butterworth, Chebyshev I/II, elliptic, Bessel) as one node, with optional zero-phase (filtfilt) filtering. This is the reachable-from-the-canvas face of flowrs-dsp's designers: the filter dropped on the graph is the same, scipy-verified one the exported program compiles.	DSP	input	output	family:enum, response:enum, order:i64, cutoff:f64, ripple_db:f64, stop_db:f64, zero_phase:enum
dsp.filter.lowpass	Low-pass filter (one-pole).	DSP	input	output	cutoff:f64, resonance:f64
dsp.fir	FIR filter over one frame, from rest: the taps written out (taps), or a windowed-sinc low-pass designed as scipy's firwin designs it (num_taps, cutoff at sample_rate, window). The same f32 arithmetic in the browser, the Host program and on a microcontroller, where it lowers with its taps as constants.	DSP	input	output	taps:String, num_taps:i64, cutoff:f64, sample_rate:f64, window:enum
dsp.gain	Scale a time signal by a gain in decibels.	DSP	input	output	gain_db:f64
dsp.ifft	Inverse FFT — frequency to time.	DSP	magnitude, phase	signal	—
dsp.mixer	Mixer — blends two signals.	DSP	input_a, input_b	output	mix:f64
dsp.moving	Moving statistic over one frame: at every sample, the stat (mean, RMS, min, max or population variance) of the last window samples, the window filling from the frame's start; last is the final window's. The same f32 arithmetic, ring buffer and square root in the browser, the Host program and on a microcontroller.	DSP	input	output, last	stat:enum, window:i64
dsp.noise	Noise — white/pink noise generator.	DSP	—	signal	type:enum, amplitude:f64
dsp.oscillator	Oscillator — generates sine/square/triangle/sawtooth waveforms.	DSP	frequency, phase	signal	waveform:enum, frequency:f64, amplitude:f64
dsp.pitch_to_note	Name the note of a buffer (note_of) or of a frequency in hertz (pitch_to_note).	DSP	hz, samples	name, pitch_class, octave, frequency	sample_rate:f64
dsp.resample	Resample — change sample rate.	DSP	signal	resampled	target_rate:i64
dsp.reverb	Comb and all-pass reverb with room size, damping and wet mix parameters.	DSP	input	output	room_size:f64, damping:f64, wet:f64
dsp.samples	Samples from bytes: samples integers of format (i16le, i16be, u16le, u8) out of a byte buffer (a sensor FIFO read over I2C or SPI, a UART), each times scale, in unit. A sample whose bytes did not arrive is 0, so the frame always has its length.	DSP	bytes	frame	format:enum, samples:i64, scale:f64, unit:String
dsp.scale	Scale — multiply a signal by a constant.	DSP	input	output	factor:f64
dsp.window	Apply a window (rectangular, Hann, Hamming or Blackman) to a signal frame.	DSP	signal	windowed	type:enum

embedded 12 nodes

Node	What it is	Category	In	Out	Parameters
embedded.adc	ADC channel read → raw counts + voltage. On the Host target (both tiers) it reads a simulated in-memory board: the channel's input as a stimulus or the node's counts sets it, midscale (2048) otherwise; on the Embassy and RTIC targets in the Code view it converts the real channel through flowrs-hal, and the voltage is raw / 4095 × vref at every tier. On the Linux target it reads the channel from Industrial I/O through flowrs-device's LinuxBoard.	Embedded	—	raw, voltage	channel:i64, vref:f64
embedded.adc.capture	ADC capture → a frame of samples voltages from one channel, interval_us apart. On the Host target (both tiers) it reads a simulated in-memory board, whose channel holds one level for the whole capture (a stimulus or midscale); on the Embassy and RTIC targets in the Code view it converts the real channel through flowrs-hal samples times, waiting interval_us between conversions; on the Linux target it reads the channel from Industrial I/O through flowrs-device's LinuxBoard. Every sample is raw / 4095 × vref in f32, exactly as embedded.adc computes its voltage: the frame the dsp.* frame nodes (graph::widgets::dsp_frame) filter on a microcontroller.	Embedded	—	frame	channel:i64, samples:i64, interval_us:i64, vref:f64
embedded.delay	Blocking delay, gated by a trigger. On the Host target (both tiers) the duration is recorded on a simulated in-memory board and nothing waits; on the Embassy and RTIC targets in the Code view it is a real delay_ms through flowrs-hal. On the Linux target it is a real sleep.	Embedded	trigger	done	duration_ms:i64
embedded.gpio.digital_in	Digital input pin — read a GPIO level. On the Host target (both tiers) it reads a simulated in-memory board, low unless something latched the pin high; on the Embassy and RTIC targets in the Code view it reads the real pin through flowrs-hal. On the Linux target it reads the GPIO line through flowrs-device's LinuxBoard (the GPIO character device).	Embedded	—	state	pin:i64
embedded.gpio.digital_out	Digital output pin — drive a GPIO high/low from a boolean. On the Host target (both tiers) the level is latched on a simulated in-memory board and no pin moves; on the Embassy and RTIC targets in the Code view it drives the real pin through flowrs-hal. On the Linux target it drives the GPIO line through flowrs-device's LinuxBoard (the GPIO character device).	Embedded	state	—	pin:i64
embedded.i2c.read	Read bytes from a register of an I2C device. On the Host target (both tiers) the device is simulated on an in-memory board: 256 registers behind a register pointer, which embedded.i2c.write and a stimulus fill; on the Embassy and RTIC targets in the Code view it is a real write-then-read through flowrs-hal. The register is the register input when wired, the register parameter when not. On the Linux target it is a write-then-read on /dev/i2c through flowrs-device's LinuxBoard.	Embedded	register	data	bus:i64, address:i64, register:i64, length:i64
embedded.i2c.write	Write bytes to an I2C device: the first byte is the register, the rest its new contents. On the Host target (both tiers) the device is simulated on an in-memory board, where embedded.i2c.read reads it back; on the Embassy and RTIC targets in the Code view it is a real write through flowrs-hal. Empty data sends nothing. On the Linux target it is a write on /dev/i2c through flowrs-device's LinuxBoard.	Embedded	data	—	bus:i64, address:i64
embedded.pwm	PWM output — set the duty cycle on a pin. On the Host target (both tiers) the frequency and duty are latched on a simulated in-memory board and no waveform is produced; on the Embassy and RTIC targets in the Code view it drives the real PWM output through flowrs-hal. On the Linux target it drives a sysfs PWM channel through flowrs-device's LinuxBoard.	Embedded	duty	—	pin:i64, frequency:i64
embedded.spi.transfer	SPI full-duplex transfer. On the Host target (both tiers) it runs on a simulated in-memory board whose bus is looped back (the bytes sent come back) unless a stimulus puts a device on it; on the Embassy and RTIC targets in the Code view it is a real transfer through flowrs-hal, framed by the chip select. On the Linux target it is a transfer on spidev through flowrs-device's LinuxBoard.	Embedded	tx_data	rx_data	bus:i64, cs_pin:i64, clock_hz:i64
embedded.timer.interval	Periodic timer tick. On the Host target (both tiers) the period is latched on a simulated in-memory board and the node ticks once per run without waiting; on the Embassy and RTIC targets in the Code view it starts a hardware timer through flowrs-hal and ticks when the period has elapsed. On the Linux target it waits on the period's cadence.	Embedded	—	tick	period_ms:i64
embedded.uart.read	Read the bytes a UART has received, up to max_len, with the count actually read; nothing waits for a byte that has not arrived. On the Host target (both tiers) the UART is on a simulated in-memory board, looped back or on a line a stimulus fills; on the Embassy and RTIC targets in the Code view it reads the real receiver through flowrs-hal. On the Linux target it reads a tty through flowrs-device's LinuxBoard.	Embedded	—	data, count	uart:i64, max_len:i64, baud:i64
embedded.uart.write	Write bytes to a UART. On the Host target (both tiers) they go onto a simulated in-memory board, whose UART is looped back unless a stimulus puts it on a line; on the Embassy and RTIC targets in the Code view they are transmitted through flowrs-hal. On the Linux target it writes a tty through flowrs-device's LinuxBoard.	Embedded	data	—	uart:i64, baud:i64

flow 5 nodes

Node	What it is	Category	In	Out	Parameters
flow.delay	Wait for duration_s seconds.	Flow	—	out	duration_s:f64
flow.log	Print a constant message and hand that same text downstream.	Flow	—	text	value:String
flow.repeat	Evaluate the body input count times and collect the results into a list.	Flow	count, body	result	count:f64
flow.statechart	A finite-state machine the graph executes and emits as Rust. The same chart runs in the interpreter and in the generated program, and that program is not parsed back. A parallel state raises done on itself when every region is final. Assigned keys live on the data wire, guards can read them, and a transition can write one key before entry.	Flow	event, events, state, history, count, elapsed, check, data	state, changed, history, trace, tags, can, data	machine:String
flow.variable	A named variable used as a source.	Flow	—	value	name:String

gen 10 nodes

Node	What it is	Category	In	Out	Parameters
gen.caption stand-in	Image → caption text. A stand-in at both tiers, not BLIP: one sentence naming the dominant colour channel.	Generative/Multimodal	image	text	—
gen.clip_image stand-in	Image → embedding. A stand-in at both tiers, not CLIP: a 16-bin histogram of the pixel bytes, L2-normalised.	Generative/Embed	image	embedding	—
gen.clip_text stand-in	Text → embedding. A stand-in at both tiers, not CLIP: a 16-bin byte histogram, L2-normalised.	Generative/Embed	text	embedding	—
gen.img2img stand-in	Image + prompt → image. A stand-in at both tiers, not a diffusion edit: the image is blended toward a colour taken from the prompt.	Generative/Diffusion	image, prompt	image	strength:f64, steps:i64
gen.inpaint stand-in	Image + mask + prompt → image. A stand-in at both tiers, not diffusion inpainting: pixels whose mask is bright become the prompt's colour.	Generative/Diffusion	image, mask, prompt	image	steps:i64
gen.txt2img stand-in	Text → image. A stand-in at both tiers, not Stable Diffusion: seeded noise pulled toward a colour taken from the prompt.	Generative/Diffusion	prompt	image	steps:i64, guidance:f64, seed:i64
gen.upscale stand-in	Image → larger image. A stand-in at both tiers, not diffusion super-resolution: nearest-neighbour scaling, 2× to 8×.	Generative/Diffusion	image	image	scale:i64
gen.vae_decode stand-in	Latent tensor → image. A stand-in at both tiers, not a VAE: the inverse of the stand-in encoder.	Generative/Latent	latent	image	—
gen.vae_encode stand-in	Image → latent tensor. A stand-in at both tiers, not a VAE: four channels per pixel, each scaled to 0..1.	Generative/Latent	image	latent	—
gen.whisper stand-in	Audio → text. A stand-in at both tiers, not Whisper: the pitch class of the dominant period, prefixed with the language hint.	Generative/Multimodal	audio	text	language:String

image 22 nodes

Node	What it is	Category	In	Out	Parameters
image.blend	Blend two images with an alpha and a normal, multiply, screen or overlay mode.	Image	image_a, image_b	blended	alpha:f64, mode:enum
image.blur	Gaussian blur of an image with sigma between 0.1 and 10.	Image	image	blurred	sigma:f64
image.brightness	Add a brightness offset (-255 to 255) to every color channel, clamped.	Image	image	adjusted	brightness:i64
image.camera export only	Live camera capture source producing image frames.	Image/Sources	—	frame	—
image.colorspace	Convert an image's pixels to the RGB, HSV, Lab or YUV color space.	Image	image	converted	to:enum
image.contrast	Scale an image's contrast by a factor (1 leaves it unchanged).	Image	image	adjusted	contrast:f64
image.crop	Crop a rectangle at x, y of the given width and height out of an image.	Image	image	cropped	x:i64, y:i64, width:i64, height:i64
image.edge_detect	Edge detection (sobel / canny).	Image	image	edges	method:enum
image.flip	Flip horizontally or vertically.	Image	image	flipped	direction:enum
image.grayscale	Convert an image to grayscale using Rec. 601 weights.	Image	image	gray	—
image.histogram	Compute an image histogram.	Image	image	histogram	—
image.load export only	Load an image from a file path.	Image	—	image	path:String
image.mask	Apply a same-size mask image to an image; a mask of a different size yields no output.	Image	image, mask	masked	—
image.morphology	Erode, dilate, open or close an image with a square kernel of the given size.	Image	image	result	operation:enum, kernel_size:i64
image.resize	Resize an image to a width and height. T0 previews with nearest-neighbour; generated code uses the chosen filter.	Image	image	resized	width:i64, height:i64, filter:enum
image.rotate	Rotate by 90/180/270 degrees.	Image	image	rotated	angle:enum
image.saturate	Scale an image's color saturation (0 is gray, 1 unchanged, up to 3).	Image	image	saturated	saturation:f64
image.save export only	Save an image to a file path.	Image	image	—	path:String, format:enum
image.sharpen	Sharpen an image with a 3x3 kernel scaled by the amount parameter.	Image	image	sharpened	amount:f64
image.template_match	Template matching → best-match location + score.	Image	image, template	x, y, score	—
image.test_pattern	A synthetic image source for T0 execution — the in-browser starting point when there is no file to load or camera to open. Generates a small test pattern (gradient / checkerboard / solid) so an image pipeline can actually run and preview live. Honest about what it is: a generator, not a disguised file load.	Image/Sources	—	image	pattern:enum, size:i64
image.threshold	Threshold to a binary image.	Image	image	binary	threshold:i64

imu 2 nodes

Node	What it is	Category	In	Out	Parameters
imu.complementary	Complementary filter: fuse an IMU's accelerometer tilt with its integrated gyro rate into one pitch angle, in degrees. It reads a raw 14-byte burst in MPU-6050 register order (accel X, Y, Z, temperature, gyro X, Y, Z; big-endian), as embedded.i2c.read takes it from ACCEL_XOUT_H; wire angle back to prev with a held wire to carry the estimate from step to step.	Sensor	imu, prev	angle	alpha:f64, dt_ms:f64, accel_lsb_per_g:f64, gyro_lsb_per_dps:f64
imu.decode	IMU Decode	Sensor	imu	accel, gyro, temperature	accel_lsb_per_g:f64, gyro_lsb_per_dps:f64, temp_lsb_per_degc:f64, temp_offset_degc:f64

instrument 6 nodes

Node	What it is	Category	In	Out	Parameters
instrument.redpitaya.acquire	Red Pitaya oscilloscope — the arming sequence, plus the two queries that follow it, plus real parsing of whatever they answer.	Instrument/Red Pitaya	status_reply, data_reply	commands, wire, count, status_query, data_query, triggered, samples, sample_count	channel:i64, decimation:i64, trigger:enum, trigger_level:f64, gain:enum, reset:enum
instrument.redpitaya.generate	Red Pitaya signal generator — the ordered command list that configures one output.	Instrument/Red Pitaya	—	commands, wire, count	channel:i64, waveform:enum, frequency:f64, amplitude:f64, output:enum, reset:enum
instrument.scpi	SCPI command — the exact line an instrument receives, and the reply it sends back.	Instrument/Protocol	reply	wire, escaped, is_query, response, response_kind, response_bytes	command:String, query:enum, model:String
instrument.sila.feature	SiLA 2 Feature — parse a Feature Definition and derive the gRPC service it generates.	Instrument/SiLA	fdl	fqi, package, service, identifiers, commands, properties, rpcs, error	—
instrument.station	Test Station — a sequence with limits over must-close instrument handles, for a lot.	Instrument/Bench	operator, serial	runs, units, passed, failed, yield_pct, pass, cpk, cpk_step, steps, last_serial, last_verdict, stdf, stdf_bytes, openhtf, audit, audit_head, transcript, mode	station:String, units:i64, start_time_millis:i64
instrument.supply	Supply Output — one channel of a catalogue power supply, as a must-close handle.	Instrument/Bench	—	commands, safe_state, count, measure	model:String, channel:i64, voltage:f64, current:f64, output:enum, address:String

io 3 nodes

Node	What it is	Category	In	Out	Parameters
io.comment	Comment node — documentation only, emits a Rust comment.	Utility	—	—	text:String
io.format	Format a value as a string.	IO	value	string	format:String
io.print	Print a value to the console.	IO	value	—	label:String

list 6 nodes

Node	What it is	Category	In	Out	Parameters
list.get	Take the element at an index of a list.	List	list	value	index:String
list.length	Count the elements of a list.	List	list	length	—
list.reverse	Reverse the order of a list.	List	list	reversed	—
list.slice	Take count elements of a list starting at the start index.	List	list	slice	start:String, count:String
list.sort	Sort a list ascending or descending.	List	list	sorted	order:enum
list.unique	Drop duplicates, keeping first occurrences in order.	List	list	unique	—

live 4 nodes

Node	What it is	Category	In	Out	Parameters
live.biosignal	A biosignal device on its open wire protocol (OpenBCI Cyton or Ganglion, Muse, g.tec Unicorn, BITalino, Polar H10), the synthetic EEG source, or a recording replayed — every channel as named series, and the electrodes as a Timeseries signal (the neuro nodes' value) with their rate and units.	Instrument/Live	—	signal, times, channels, lines, flagged, format, source, timeseries, rate, units	stream:String, channel:String
live.rtt	An RTT up channel from a board through a debug probe or from a twin: text lines, defmt decoded against the firmware ELF, or a binary channel read as samples.	Instrument/Live	—	signal, times, channels, lines, flagged, format, source	stream:String, channel:String
live.serial	Maker serial telemetry — Teleplot, Arduino Serial Plotter or CSV lines, from Web Serial, a native port, Teleplot's UDP port or a twin's UART — as named series with timestamps.	Instrument/Live	—	signal, times, channels, lines, flagged, format, source	stream:String, channel:String
live.symbol	Firmware globals read by name at a rate through a probe or from a twin, typed from the ELF's DWARF — plots that need no firmware instrumentation.	Instrument/Live	—	signal, times, channels, lines, flagged, format, source	stream:String, channel:String

logic 7 nodes

Node	What it is	Category	In	Out	Parameters
logic.and	Logical AND of two booleans.	Logic	a, b	result	—
logic.compare	Compare two numeric values (== by default).	Logic	a, b	result	op:enum
logic.if	Conditional selection: true_val if condition else false_val.	Logic	condition, true_val, false_val	result	—
logic.not	Logical NOT (invert a boolean).	Logic	value	result	—
logic.or	Logical OR of two booleans.	Logic	a, b	result	—
logic.route	Route a value to one of two outputs by comparing it against a literal.	Logic	value	match, otherwise	key:String, op:enum, compare:String, compare_type:enum
logic.toggle	Toggle (flip-flop) — flips a stored boolean on each trigger.	Logic	trigger	state	initial:bool

math 8 nodes

Node	What it is	Category	In	Out	Parameters
math.abs	Absolute value of a number.	Math	value	abs	—
math.add	Add two numbers, a plus b.	Math	a, b	sum	—
math.clamp	Clamp a value between min and max.	Math	value, min, max	clamped	—
math.div	Divide two numbers, a divided by b.	Math	a, b	quotient	—
math.mod	Remainder of a divided by b.	Math	a, b	remainder	—
math.mul	Multiply two numbers, a times b.	Math	a, b	product	—
math.neg	Negation (multiply by -1).	Math	value	neg	—
math.sub	Subtract two numbers, a minus b.	Math	a, b	diff	—

mavlink 4 nodes

Node	What it is	Category	In	Out	Parameters
mavlink.command	MAVLink Command	MAVLink	trigger	status, hash	link:String, dialect:enum, system:u32, key_file:String, timeout_ms:u32, command:String, param1:f64, param2:f64, param3:f64, param4:f64, param5:f64, param6:f64, param7:f64, approval:String
mavlink.heartbeat	MAVLink Heartbeat	MAVLink	—	armed, mode, status, autopilot	link:String, dialect:enum, system:u32, key_file:String, timeout_ms:u32
mavlink.setpoint	MAVLink Setpoint	MAVLink	position, yaw	status	link:String, dialect:enum, system:u32, key_file:String, timeout_ms:u32, frame:enum, horizontal_m:f64, altitude_m:f64, rate_hz:f64, seconds:f64, approval:String
mavlink.telemetry	MAVLink Telemetry	MAVLink	—	value, value2, value3, time	link:String, dialect:enum, system:u32, key_file:String, timeout_ms:u32, message:String, field:String, field2:String, field3:String, rate_hz:f64, initial:String

microphone 1 nodes

Node	What it is	Category	In	Out	Parameters
microphone stand-in	A frame of 1024 samples from the microphone — a stand-in at both tiers: a synthetic 1 kHz tone at -20 dBFS at the chosen sample rate, not a recording. No device is opened.	Signal/Sources	—	output	sample_rate:u32

ml 15 nodes

Node	What it is	Category	In	Out	Parameters
ml.classify	Classify a feature vector with a trained model → class index + confidence.	ML	model, input	class, confidence, scores	—
ml.dense	Register all ML widgets into registry. A dense (fully-connected) layer: output = input × weights + bias.	ML	input, weights, bias	output	—
ml.export	Export a trained model as standalone no_std Rust — the deploy step.	ML	model	source	format:String
ml.infer_onnx	ONNX inference: model bytes and one numeric row in, the flattened output out.	ML	model, input	output	—
ml.inference	Run a tensor through an ONNX model loaded from model_path.	ML	input	output	model_path:String
ml.matmul	Matrix product of two tensors.	ML	a, b	result	—
ml.model	A trained model held as JSON — the second source for the Model wire type.	ML	—	model	json:String
ml.onnx	An ONNX model from the model store — the second backend's source.	ML	—	model	file:String
ml.quantize	Quantize a model to int8 — the step that makes it fit on a microcontroller.	ML	model	model, bytes, saved	—
ml.relu	ReLU activation applied element-wise to a tensor: max(x, 0).	ML	input	output	—
ml.sigmoid	Sigmoid activation applied element-wise to a tensor: 1 / (1 + e^-x).	ML	input	output	—
ml.softmax	Softmax activation (with axis parameter).	ML	input	output	axis:i64
ml.tanh	Hyperbolic tangent activation applied element-wise to a tensor.	ML	input	output	—
ml.tensor	Create a tensor from a shape.	ML	—	tensor	shape:String, values:String, axes:String
ml.train	Train a classifier from a table — the "collect → train → deploy" loop, running entirely in the browser.	ML	data	model, loss, accuracy	label:String, hidden:i64, epochs:i64, learning_rate:f64, seed:i64

msg 6 nodes

Node	What it is	Category	In	Out	Parameters
msg.get	Read one field. Emits nothing when the field is absent.	Message	msg	value	key:String
msg.keys	The field names present on a message.	Message	msg	keys	—
msg.merge	Merge two messages; fields from over win.	Message	base, over	out	—
msg.new	Build a message, optionally seeding one field from a wired value.	Message	value	msg	key:String
msg.remove	Remove one field from a message record.	Message	msg	out	key:String
msg.set	Set one field, returning the updated message.	Message	msg, value	out	key:String, value:String, value_type:enum

neural 10 nodes

Node	What it is	Category	In	Out	Parameters
neural.argmax	Index of the largest element of a tensor.	Neural/Ops	input	index	—
neural.classify	Image classification → class-probability tensor.	Neural/Vision	model, image	probs	—
neural.detect	Object detection → bounding boxes, decoded from the wired model's output by the head you declare: yolov8 (output [1, 4+C, N]) or yolov5 (output [1, N, 5+C]), then class-aware non-maximum suppression. With no head declared it does not run, and says why.	Neural/Vision	model, image	detections	head:enum, confidence:f64, iou:f64
neural.embed	Encode a tensor into an embedding vector.	Neural/Run	model, input	embedding	—
neural.infer	Run a model on a tensor → a tensor.	Neural/Run	model, input	output	—
neural.load_model	Load an ONNX model into a runnable session.	Neural/Sources	—	model	path:String
neural.nms	Non-maximum suppression over detections.	Neural/Vision	detections	detections	iou:f64
neural.segment	Semantic segmentation → a label mask, decoded from the wired model's output by the layout you declare: nchw-logits (output [1, C, H, W], one score plane per class) gives each pixel the id of its highest-scoring class. With no layout declared it does not run, and says why.	Neural/Vision	model, image	mask	layout:enum
neural.softmax	Softmax over the last axis of a tensor.	Neural/Ops	logits	probs	—
neural.tokenize export only	Tokenize text into an input-id tensor.	Neural/Text	text	tokens	tokenizer:String

neuro 49 nodes

Node	What it is	Category	In	Out	Parameters
neuro.asr	Artifact subspace reconstruction as EEGPrep runs it at clean_rawdata's defaults: calibrates on the cleanest windows of the recording, then rebuilds, half a window at a time, the principal components whose power exceeds the calibration's by more than the cutoff in standard deviations.	Neuro	signal	signal, calibration_s, repaired, updates	cutoff:f64
neuro.bandpower	Power in a frequency band for every channel: the Welch spectrum (MNE's defaults) summed over the bins inside the band times the bin width, and the mean of that over channels.	Neuro	signal	power, mean	band_low:f64, band_high:f64, n_fft:usize, n_overlap:usize, n_per_seg:usize
neuro.baseline	Holds a candidate classifier's predictions against a classical baseline's on the same test epochs: both accuracies, the margin, and an exact McNemar test on the epochs where they disagree. Every learned model belongs beside one.	Neuro	candidate, baseline, test	candidate_accuracy, baseline_accuracy, margin, p_value, verdict	—
neuro.cca	SSVEP detection by canonical correlation (Lin et al., 2007): each epoch gets the stimulus frequency whose sine and cosine references, with their harmonics, correlate best with it.	Neuro	epochs	predictions, accuracy, scores, classes	freqs:String, harmonics:usize, labels:String
neuro.cdsa	A compressed spectral array: one channel's Welch spectrum (MNE's defaults) over sliding windows, in decibels, the trend clinical EEG viewers draw beside the traces. The array window by window, the frequencies, and the window count.	Neuro	signal	psd_db, freqs, windows	channel:String, window:f64, step:f64, fmin:f64, fmax:f64, n_fft:usize
neuro.channel	Takes one channel of a signal as a plain sample buffer, with its sample rate, for the DSP nodes and the front panel's charts.	Neuro	signal	samples, sample_rate	channel:String
neuro.cmr	Subtracts, at every sample, the median across channels from each channel: SpikeInterface's global common median reference, which removes noise every electrode shares before spikes are detected.	Neuro	signal	signal	—
neuro.connectivity	Coherence, phase-locking value or weighted phase-lag index between every pair of channels across epochs, as mne-connectivity's spectral_connectivity_epochs computes them, averaged over a band; the matrix (channels by channels, symmetric, zero diagonal) goes with the channel names, ready for a connectivity circle.	Neuro	epochs	matrix, channels, mean	method:enum, mode:enum, fmin:f64, fmax:f64, mt_bandwidth:f64
neuro.covariance	One covariance matrix per epoch, by pyRiemann's estimators (sample, Ledoit-Wolf, OAS, Schaefer-Strimmer), with optional shrinkage: the symmetric positive-definite matrices the Riemannian nodes work on.	Neuro	epochs	covariances, labels, count	estimator:enum, shrinkage:f64
neuro.csd	The current source density (surface Laplacian) by spherical splines, as MNE's compute_current_source_density computes it at its defaults (lambda2 1e-5, stiffness 4, 50 Legendre terms, sphere fitted to the electrodes); the units become the input's per square metre.	Neuro	signal	signal	electrodes:String, electrode_units:enum, electrode_frame:enum, lambda2:f64, stiffness:f64, n_legendre_terms:usize, sphere:String
neuro.csp	Common spatial patterns (MNE's CSP) fitted on two classes of training epochs, applied to epochs: the components whose variance differs most between the classes, their log-power features, the filters and the patterns.	Neuro	train, epochs	components, features, filters, patterns	components:usize
neuro.csp_lda	Common spatial patterns fitted on two classes of training epochs (MNE's CSP), their log-power features, and linear discriminant analysis on them: the classic motor-imagery classifier.	Neuro	train, test	predictions, accuracy, scores, classes	components:usize
neuro.ecg	Cleans one ECG channel and finds its R-peaks with NeuroKit2's default method (a 0.5 Hz high-pass and a mains moving average, then a gradient threshold); returns the cleaned channel with the R-peaks as events, the peak samples and the mean rate in beats per minute.	Neuro	signal	clean, peaks, rate	channel:String, powerline:f64
neuro.eda	Cleans one electrodermal channel (a 3 Hz low-pass) and splits it into its slow tonic level and fast phasic responses with NeuroKit2's default method (0.05 Hz high- and low-pass), as a signal with clean, tonic and phasic channels.	Neuro	signal	signal	channel:String
neuro.emg	Cleans one EMG channel (a 100 Hz high-pass) and computes its linear envelope with NeuroKit2's method (Teager-Kaiser energy, a 10-400 Hz band-pass, rectification and an 8 Hz low-pass) at the signal's own rate, as a signal with clean and envelope channels; needs sampling above 800 Hz.	Neuro	signal	signal	channel:String
neuro.epochs	Cuts a signal into epochs around its events, as MNE's Epochs does at its defaults: -0.2 s to 0.5 s around each event, each epoch's mean from its start to 0 s removed; epochs that run off the data are dropped.	Neuro	signal	epochs, count	events:String, tmin:f64, tmax:f64, baseline:String
neuro.erp	Averages epochs into an event-related potential, as MNE's Epochs.average does, and says how many epochs went into it.	Neuro	epochs	evoked, count	event:String, baseline:String
neuro.erpimage	One channel's epochs as an image, one row per epoch (MNE's plot_epochs_image): optionally sorted by the mean over a window, and smoothed across neighbouring epochs. The image row by row, its row count, and the order of the epochs in it.	Neuro	epochs	image, rows, order	channel:String, sort:String, sigma:f64
neuro.fbcca	Filter-bank CCA for SSVEP, as the TRCA-SSVEP reference computes it: CCA in each sub-band of a Chebyshev filter bank, the correlations weighted and summed. Needs a sample rate above 200 Hz.	Neuro	epochs	predictions, accuracy, scores, classes	freqs:String, harmonics:usize, labels:String, bands:usize
neuro.gfp	Global field power of an evoked response: the standard deviation across channels at each moment (MNE's GFP for EEG; RMS for MEG), with when and how high it peaks. The butterfly view draws it under every channel.	Neuro	signal	gfp, peak_time, peak	mode:enum
neuro.hrv	Heart-rate variability from a signal's beat events (the R-peaks of ECG R-Peaks, or PPG peaks): NeuroKit2's time-domain indices (MeanNN, SDNN, RMSSD, pNN50 and the rest) and its frequency-domain band powers (ULF to VHF, LF/HF), as names and values, with RMSSD, SDNN and LF/HF on their own ports.	Neuro	signal	names, values, rmssd, sdnn, lf_hf	event:String, normalize:enum
neuro.ica	Independent component analysis by Picard, which gives Infomax, extended Infomax or FastICA solutions: whitens the channels by PCA (to the data's rank unless told otherwise) and returns the component sources with the unmixing and mixing matrices.	Neuro	signal	sources, unmixing, mixing, n_iter, converged	method:enum, n_components:usize, max_iter:usize, tol:f64, seed:i64
neuro.ica_apply	Subtracts the chosen independent components (their sources times their columns of the mixing matrix) from the signal ICA was fitted on; everything else, its mean included, is left as it was.	Neuro	signal, unmixing, mixing, exclude	signal	exclude:String
neuro.iclabel	Classifies each independent component as brain, muscle, eye, heart, line noise, channel noise or other with SCCN's ICLabel network (run on tract), from its scalp map, spectrum and autocorrelation computed as EEGPrep computes them; flags components for removal by EEGLAB's rule (Muscle or Eye above 0.9 by default).	Neuro	signal, unmixing, mixing	probabilities, labels, exclude	model:String, electrodes:String, electrode_units:enum, electrode_frame:enum, flag:String
neuro.mdm	Minimum distance to mean: a mean covariance per class from the training epochs, and each test epoch given the class whose mean is nearest, as pyRiemann's MDM. A strong, simple baseline for motor imagery and ERPs.	Neuro	train, test	predictions, accuracy, scores, classes	estimator:enum, shrinkage:f64, xdawn:usize, metric:enum
neuro.morlet	A time-frequency map by Morlet wavelets, as MNE's tfr_array_morlet computes it, with zero_mean stated explicitly (MNE changed its default between versions), as a signal with one channel per channel and frequency (Cz@10Hz): per epoch for power and phase, averaged over epochs for avg_power and inter-trial coherence.	Neuro	signal	tfr, freqs	freqs:String, n_cycles:String, zero_mean:enum, output:enum
neuro.multitaper	A time-frequency map by DPSS-tapered complex exponentials, as MNE's tfr_array_multitaper computes it, as a signal with one channel per channel and frequency (Cz@10Hz): per epoch for power, averaged over epochs for avg_power and inter-trial coherence.	Neuro	signal	tfr, freqs	freqs:String, n_cycles:String, zero_mean:enum, output:enum, time_bandwidth:f64
neuro.notch	Removes mains interference at a frequency and its harmonics. By default with MNE's default notch (method fir): one zero-phase FIR band-stop with a stop band per frequency, a Hamming-windowed firwin design 3.3 / (trans_bandwidth / 2) seconds long, applied by overlap-add with MNE's padding. Method iir gives MNE's IIR notch instead: one biquad per frequency (a first-order Butterworth band-stop), applied forward and backward so nothing is delayed.	Neuro	signal	signal	method:enum, freq:f64, harmonics:usize, notch_width:f64, trans_bandwidth:f64
neuro.open	Opens an EDF, EDF+, BDF, GDF, WFDB, XDF or BrainVision recording from the file store as one signal: its channels with their sample rate, names and units, and its annotations as events.	Neuro	—	signal, channels, sample_rate, duration, events, summary, warnings	name:String, format:enum, channels:String
neuro.open_h5	Opens an NWB, SNIRF or EEGLAB (MATLAB v7.3) recording from the file store as one signal, reading only the window asked for: its channels with their sample rate, names and units, and its event tables as events.	Neuro	—	signal, channels, sample_rate, duration, events, summary, warnings	name:String, format:enum, series:String, start:f64, duration:f64, channels:String
neuro.open_zarr	Opens an NWB recording from a LINDI index in the file store (a DANDI asset's objects as Zarr, its fetched chunks inlined), as one signal with its events.	Neuro	—	signal, channels, sample_rate, duration, events, summary, warnings	name:String, format:enum, series:String, start:f64, duration:f64, channels:String
neuro.pick	Keeps the named channels of a signal, in the order named.	Neuro	signal	signal	channels:String
neuro.potato	Artifact detection: the potato is calibrated on clean epochs (their mean covariance and the spread of distances to it), and each scored epoch gets a z-score; those at or above the threshold are flagged, as pyRiemann's Potato.	Neuro	calibration, epochs	z, clean, rejected	estimator:enum, shrinkage:f64, metric:enum, threshold:f64, iterations:usize
neuro.ppg	Cleans one photoplethysmogram channel and finds its systolic peaks with NeuroKit2's default method (Elgendi: a 0.5-8 Hz band-pass, then two moving averages of the squared signal); returns the cleaned channel with the peaks as events, the peak samples and the mean rate in beats per minute.	Neuro	signal	clean, peaks, rate	channel:String
neuro.psd_multitaper	The power spectral density of every channel by DPSS tapers, as MNE's psd_array_multitaper computes it at its defaults (half-bandwidth 4, low-bias tapers, no adaptive weights), and the frequency where the channel-averaged spectrum peaks.	Neuro	signal	psd, peak_hz	fmin:f64, fmax:f64, bandwidth:f64, normalization:enum
neuro.reref	Re-references every channel: to the common average of all channels (CAR), or to the mean of named reference channels, as MNE's set_eeg_reference does.	Neuro	signal	signal	reference:String
neuro.resample	Changes a signal's sample rate with an anti-aliasing polyphase filter (scipy's resample_poly: Kaiser-windowed, beta 5), so content above the new Nyquist frequency is removed rather than folded back.	Neuro	signal	signal	rate:f64
neuro.spd_distance	The distance from each SPD matrix on `a` to its match on `b` (or to b's only matrix, such as a mean): Riemannian, log-Euclidean or Euclidean, as pyRiemann measures them.	Neuro	a, b	distances, mean	metric:enum
neuro.spd_mean	The mean of SPD matrices: Riemannian (pyRiemann's mean_riemann, by gradient descent), log-Euclidean, or arithmetic.	Neuro	covariances	mean	metric:enum
neuro.spike_metrics	Firing rate, presence ratio, ISI-violation ratio and SNR for every unit, a unit being one event label of the signal (what Detect Spikes writes, or a sorting's units), computed as SpikeInterface's quality metrics are.	Neuro	signal	units, firing_rate, presence_ratio, isi_violations, snr, summary	bin_s:f64, isi_ms:f64, ms_before:f64, ms_after:f64
neuro.spikes	Finds spikes channel by channel as SpikeInterface's by_channel detector does: samples beyond a threshold in MAD noise levels that are the extreme of the samples around them. The signal comes out unchanged, its events replaced by one `spike <channel>` event per spike.	Neuro	signal	signal	sign:enum, threshold:f64, exclude_ms:f64
neuro.spoc	Source power comodulation (pyRiemann's SPoC): spatial filters whose power follows a continuous target, read from each training epoch's label as a number; applied to epochs, with the filters and patterns.	Neuro	train, epochs	components, features, filters, patterns	components:usize, estimator:enum
neuro.tangent_space	Maps SPD matrices to vectors in the tangent space at a reference matrix (wire one to `reference`, or their own Riemannian mean is used), so ordinary linear methods can work on them: pyRiemann's TangentSpace.	Neuro	covariances, reference	vectors, dimension	—
neuro.tfr	Morlet wavelet power of one channel, averaged over epochs, as MNE's tfr_array_morlet computes it (with zero_mean stated, since MNE's default changed), optionally relative to a baseline (MNE's logratio, percent, zscore and the rest). The map frequency by frequency, the frequencies, and the frequency of greatest mean power.	Neuro	epochs	power, freqs, peak_hz	channel:String, fmin:f64, fmax:f64, fstep:f64, cycles:String, zero_mean:bool, baseline:String, mode:enum
neuro.topomap	The scalp map of every channel at one moment, interpolated as MNE's plot_topomap does (Clough-Tocher on the electrodes' triangulation, the head's edge reached by extra points), from standard 10-05 positions; its grid, row by row from the back of the head, and the colour limit MNE would use.	Neuro	signal	grid, limit	time:f64, interp:enum, extrapolate:enum, res:usize
neuro.trca	Task-related component analysis for SSVEP (Nakanishi et al., 2018), as the MIT TRCA-SSVEP reference trains and tests it: a filter bank, a spatial filter and template per class from the training epochs, and each test epoch given the class it correlates with best. Needs a sample rate above 200 Hz.	Neuro	train, test	predictions, accuracy, scores, classes	bands:usize, mode:enum
neuro.ts_lr	Covariances mapped to the tangent space at the training mean, then L2-regularized logistic regression (MOABB's TS+LR pipeline, the strongest classical baseline in its benchmark).	Neuro	train, test	predictions, accuracy, scores, classes	estimator:enum, shrinkage:f64, xdawn:usize, C:f64
neuro.welch	The power spectral density of every channel by Welch's method, at MNE's defaults (256-point FFT, Hamming window, no overlap), and the frequency where the channel-averaged spectrum peaks.	Neuro	signal	psd, peak_hz	fmin:f64, fmax:f64, n_fft:usize, n_overlap:usize, n_per_seg:usize
neuro.xdawn	xDAWN spatial filters (pyRiemann's Xdawn) fitted on training epochs: per class, the components that best raise the averaged response over the rest of the signal; applied to epochs, with the filters and patterns.	Neuro	train, epochs	components, features, filters, patterns	components:usize, estimator:enum

record 8 nodes

Node	What it is	Category	In	Out	Parameters
record.capability	Capability — is the process inside its limits with room, or passing by luck?	Record	runs, r1, r2, r3, r4	capability, count, worst, worst_cpk	—
record.collect	Collect — append a measurement to a running list.	Record	list, measurement	list	—
record.export	Export — serialise a run into whichever report the shop already reads.	Record	run	report, bytes, byte_count	format:enum
record.file	A file from the browser's file store, as a report and as bytes.	Record	—	report, bytes, size	name:String
record.import	Import — read a report back into runs.	Record	report, bytes	run, runs, count	format:enum
record.measure	Measure — judge a reading against a limit and emit a [Measurement].	Record	value	measurement, verdict, pass, marginal	name:String, unit:String, unit_code:String, limit:enum, lower:f64, upper:f64, lower_inclusive:bool, upper_inclusive:bool, guard_band:f64
record.run	Run — assemble measurements and the unit's identity into a [TestRun].	Record	measurements, m1, m2, m3	run, verdict, pass	test_name:String, dut_id:String, station_id:String, operator:String, sw_version:String, phase:String, part_number:String, revision:String, start_time_millis:i64, duration_millis:i64
record.yield	Yield — pass/fail statistics over a batch of runs, plus the top failing characteristic.	Record	runs, r1, r2, r3, r4	total, passed, failed, yield_pct, top_failure	skip_policy:enum

ros 2 nodes

Node	What it is	Category	In	Out	Parameters
ros.publish	ROS 2 Publish	ROS	value, value2, value3	message	topic:String, type:String, field:String, field2:String, field3:String, frame_id:String, fields:String, qos:enum
ros.subscribe	ROS 2 Subscribe	ROS	—	value	topic:String, type:String, field:String, initial:String, qos:enum

signal 1 nodes

Node	What it is	Category	In	Out	Parameters
signal.sine	Sine oscillator source at a frequency and sample rate.	Signal/Sources	—	output	freq:f32, sample_rate:u32

stats 21 nodes

Node	What it is	Category	In	Out	Parameters
stats.anova	One-way ANOVA of a value column grouped by a group column, giving the F statistic and p-value.	Stats	data	f_statistic, p_value	value_column:String, group_column:String
stats.chi_square	Chi-square test of independence.	Stats	contingency_table	chi2, p_value, dof	—
stats.correlation	Pearson correlation between two columns of a table.	Stats	data	correlation	column_x:String, column_y:String
stats.count	Count the rows of a table, or the readings in one column.	Stats	data	count	column:String
stats.covariance	Covariance between two columns of a table.	Stats	data	covariance	column_x:String, column_y:String
stats.describe	Descriptive statistics summary.	Stats	data	summary	column:String
stats.histogram	Histogram of one column: bin edges and counts for the chosen number of bins.	Stats	data	bins, counts	column:String, num_bins:i64
stats.kurtosis	Kurtosis (excess) of a distribution.	Stats	data	kurtosis	column:String
stats.max	Largest reading in a column or signal.	Stats	data	max	column:String
stats.mean	Arithmetic mean of a column or signal.	Stats	data	mean	column:String
stats.median	Median of a column or signal.	Stats	data	median	column:String
stats.min	Smallest reading in a column or signal.	Stats	data	min	column:String
stats.mode	Mode (most frequent value).	Stats	data	mode	column:String
stats.quantile	The q quantile (0 to 1) of one column of a table.	Stats	data	quantile	column:String, q:f64
stats.regression	Simple linear regression.	Stats	data	slope, intercept, r_squared	x_column:String, y_column:String
stats.skewness	Skewness of a distribution.	Stats	data	skewness	column:String
stats.std_dev	Standard deviation (with configurable ddof).	Stats	data	std_dev	column:String, ddof:i64
stats.sum	Sum of the readings in a column or signal.	Stats	data	sum	column:String
stats.summary	Mean of an input signal, as a single summary number.	Stats/Analysis	input	mean	—
stats.t_test	Independent-samples t-test.	Stats	group_a, group_b	t_statistic, p_value	—
stats.variance	Variance (with configurable ddof).	Stats	data	variance	column:String, ddof:i64

text 7 nodes

Node	What it is	Category	In	Out	Parameters
text.case	Convert text to upper or lower case.	Text	text	out	mode:enum
text.contains	Whether the text contains a substring.	Text	text	found	needle:String
text.join	Join a list into one string.	Text	parts	text	separator:String
text.length	Count the characters of a text.	Text	text	length	—
text.replace	Replace every occurrence of one substring with another.	Text	text	out	find:String, replace:String
text.split	Split text on a separator.	Text	text	parts	separator:String
text.trim	Trim surrounding whitespace.	Text	text	out	—

twin 1 nodes

Node	What it is	Category	In	Out	Parameters
twin.capture	Read a waveform captured from a digital twin.	Instrument/Twin	—	signal, sample_rate, aliased, source, serial	capture:String

unit 1 nodes

Node	What it is	Category	In	Out	Parameters
unit.convert	Convert a number from one unit to another — m/s to km/h, Cel to K, uV to V — with the factor and offset derived from the two UCUM codes, so a unit mismatch on a wire is fixed in plain sight.	Units	value	converted	from:String, to:String

vec3 10 nodes

Node	What it is	Category	In	Out	Parameters
vec3.add	Add two 3-vectors component-wise.	Vector	in1, in2	out	in1:vec3, in2:vec3
vec3.combine	Build a vec3 from three scalars — the only entry point from the math.* family.	Vector	in1, in2, in3	out	—
vec3.constant	A constant 3-vector set by the value parameter.	Vector	—	out	value:vec3
vec3.divide	Divide two 3-vectors component-wise.	Vector	in1, in2	out	in1:vec3, in2:vec3
vec3.invert	amount - in. Not 1 - in — see the module docs.	Vector	in, amount	out	in:vec3, amount:vec3
vec3.mix	bg(1-w) + fgw. mix = 0 yields bg — see the module docs.	Vector	bg, fg, mix	out	bg:vec3, fg:vec3, mix:vec3
vec3.multiply	Multiply two 3-vectors component-wise.	Vector	in1, in2	out	in1:vec3, in2:vec3
vec3.normalize	Unit-length form of a width-3 vector. MaterialX normalize, lane width 3.	Vector	in	out	in:vec3
vec3.separate	Split a vec3 into its three lanes.	Vector	in	outx, outy, outz	in:vec3
vec3.subtract	Subtract two 3-vectors component-wise.	Vector	in1, in2	out	in1:vec3, in2:vec3

video 10 nodes

Node	What it is	Category	In	Out	Parameters
video.extract_frame	Pull a single frame (an image) by index.	Video/Bridge	video	frame	index:i64
video.fps	Change a clip's frame rate by dropping or repeating frames, and report the resulting rate.	Video/Edit	video	video, fps	fps:f64, source_fps:f64
video.open stand-in	Open a clip from a file — a stand-in for a video decoder at both tiers: it reads flowRS's own uncompressed frame container (what video.write writes), not MP4, AV1 or H.264. A real video file yields no clip.	Video/Sources	—	video	path:String
video.overlay	Composite an image over the stream (watermark / overlay).	Video/Edit	video, overlay	video	x:i64, y:i64
video.resize	Resize every frame of a clip to a width and height (nearest-neighbour at T0).	Video/Edit	video	video	width:i64, height:i64
video.scene_detect	Detect scene cuts → detections (one per cut, with its timestamp).	Video/Analysis	video	cuts	threshold:f64
video.test_clip	Synthesise a clip from parameters alone — the Video pillar's T0 source./// Synthesise a clip from parameters alone — the Video pillar's T0 source.	Video/Sources	—	video	frames:i64, width:i64, height:i64, pattern:enum, dx:i64, dy:i64
video.track	Track objects across frames → per-frame detections with stable ids.	Video/Analysis	video, seed	tracks	search:i64
video.trim	Trim to a time range (seconds).	Video/Edit	video	video	start:f64, duration:f64, fps:f64
video.write stand-in	Write a clip to a file — a stand-in for a video encoder at both tiers: the frames go into flowRS's own uncompressed frame container with the codec's name recorded, and no AV1 or H.264 bitstream is produced, whatever the path's extension says.	Video/Sinks	video	—	path:String, codec:String

vision 11 nodes

Node	What it is	Category	In	Out	Parameters
vision.blobs	Blob detection → bounding boxes. The detection pillar's classical source.	Vision/Analysis	binary	detections, count	min_area:i64
vision.connected_components	Label 8-connected regions → labeled image + region count.	Vision/Analysis	binary	labels, count	—
vision.contours	Trace contours of a binary image → detections (one polygon per blob).	Vision/Features	binary	contours	—
vision.corners	FAST corner / keypoint detection → detections.	Vision/Features	image	keypoints	threshold:i64
vision.draw_detections	Draw detection boxes onto an image → annotated image.	Vision/Analysis	image, detections	annotated	—
vision.hough_lines	Probabilistic Hough line detection → detections (one polar line each).	Vision/Features	edges	lines	vote_threshold:i64
vision.optical_flow	Dense optical flow between two consecutive frames → flow field tensor.	Vision/Motion	prev, next	flow	window:i64
vision.orb	ORB features → keypoint detections + binary descriptor tensor.	Vision/Features	image	keypoints, descriptors	n_features:i64
vision.otsu_threshold	Otsu automatic thresholding → binary mask.	Vision/Analysis	image	mask	—
vision.to_tensor	Convert an image into a normalized CHW tensor (the neural-pillar bridge).	Vision/Bridge	image	tensor	layout:enum
vision.warp_perspective	Warp an image by a 3×3 homography (perspective transform).	Vision/Geometry	image	warped	homography:String