Nodes

The audio plane crossing into the signal plane. A stream has no frame of its own — a tap hands over whatever the last blocks held — so `mode` is the framing the analysis asks for rather than the one the clock happened to give: the samples as they came, a window of a fixed length, or one level per fixed run of them.

How much a signal resembles itself shifted by each lag. The frame as handed is the window: a `Buffer` in front sets how much is seen. Each lane along `axis` becomes its autocorrelation over `lags` lags, so a periodic signal peaks again at its period.

A rolling window along one axis. Keeps the most recent `size` entries; an axis past the rank is a new one.

A steady tick, in beats a minute, hertz or seconds. `pulse` is one on an update a tick landed in, `phase` where it is inside the current tick, and `count` the ticks since the last reset.

A number, given a shape. How a scalar becomes an array of the size a node downstream wants.

The stream as it was a moment ago, counted in samples, seconds or updates.

A drawing widget's picture, as a frame. Every stroke a `paint` widget holds — a hand's or `control paint`'s — as an [H, W, 4] RGBA frame spanning 0..1. Feed `graphics:SignalIn` with it to put the drawing on the GPU.

The eigenvalues and eigenvectors of a square symmetric matrix. Or of its Laplacian, which reads the matrix as a graph instead.

Pull a frame apart into the oscillations it is made of, fastest first.

The spectrum, both ways. Samples into one-sided bins, and those bins back into samples.

Keep one band of the spectrum. Zero-phase, so nothing is shifted in time, or causal, so nothing waits.

Generate a sinusoidal FM signal in real-time sample blocks. Carrier and modulator are frequencies in Hz. Index sets phase deviation: zero gives a sine wave; increasing it adds sidebands around the carrier. Carrier and modulator phases persist between blocks and parameter changes. Output is a float32 array in [-1, 1] with sampling-rate metadata. Connect it to Buffer, Psd, or Peaks to inspect the spectrum. Choose output/sfreq high enough for the sidebands; this source does not prevent aliasing.

Several strings become one, joined in order or placed into a template.

Move a signal up or down the spectrum. By a fixed number of hertz, without changing its speed.

The first object in a piece of text becomes a table.

One elementwise function over the frame, chosen by name. Shape and metadata are untouched.

The graphics plane crossing into the signal plane. A render is more numbers than the rest of a patch wants to carry, so `size` bounds each picture axis and the frame still says what it was rendered from. `mode` is what a picture is usually wanted for: its texels, its brightness, or the profile that brightness draws across the frame or down it.

A signal's envelope, phase and instantaneous frequency. How big its swing is, where in its cycle it stands, and how fast that is turning.

Sample and hold: the value the last `take` caught. It glides to a newly caught value over `ramp`. Shape and metadata are the input's.

Lay several frames end to end, or stack them. Along one axis, or onto a new axis named after their senders.

A low-frequency oscillator. One sample per update to modulate a param, or a block of samples to feed a signal.

Receive an LSL stream: [channels, samples] per tick, with its labels and rate.

Publish a frame as an LSL stream, with the labels and rate it arrived with.

Scale and shift every value, then remap the range. `bound` says what happens to a value that lands outside it. Shape and metadata are untouched.

Write the sample rate or the channel names onto a frame. For a source that does not carry its own.

Receive MIDI: every held note, every controller, the pitch wheel and aftertouch.

Send MIDI: note-on for a number that appears, note-off for one that goes.

Uniform, normal or pink noise, one independent stream per channel.

Put a signal on a common scale, from statistics over a window of its own past.

Combine several frames into one. Arithmetic folded left with numpy broadcasting, a matrix product, or a correlation.

Receive OSC messages: one table entry per address, the latest value each.

Send a table as OSC messages, one address per entry.

How much power sits at each frequency, in Hz, over the last axis.

Pull every pitch onto the nearest note of a scale. A value is a frequency in Hz, or volts per octave with C4 at 0 V. `index` says which degree of the scale each one landed on. Shape and metadata are the input's.

Collapse one axis to a single value. One value per position on the other axes: a mean, a spread, an extreme or a total.

Change the sample rate of a complete window; use Buffer to set its length.

Reorder the axes of a frame, then re-cut the entries into a new shape.

Keep part of one axis. Named by label, or by numpy index with keep and drop applied in either order.

Take the edge off a signal, as a running mean or as an exponential decay.

Let one of several wires through, chosen by number. So a signal can pick the route.

Several wires become one table, each under a key.

Put every member of a table on a common scale. Each member is measured against its OWN past, so features in different units become comparable numbers without one of them dominating.

One field out of a table, on the output that matches what the field holds.

A string, which an expression can build out of anything else in the patch.

Turn a signal into a decision. One where it is past the level, zero where it is not.

A table becomes JSON text. An object, with arrays as lists and strings as strings.

How a signal's frequencies come and go across the frame. Which one spectrum cannot show.

The device's input: the channels `channels` names, in order, or all of them.

The sound device: what reaches `input` is heard, times `gain`. `channels` names the device channels it lands on, the first incoming channel on the first channel named, so two AudioOuts can hold different pairs of one card. Every AudioOut on the device sums.

A WAV file as audio. As many channels as the file holds, resampled to the engine's rate.

Its input split into bands, each one at its own gain, added back up. The half of a vocoder that speaks: `gains` from a `BandFollow` puts that signal's shape on this one, and a shape is as many bands wide as it says, so the two banks cannot disagree about the count. With nothing behind `gains` every band is open, which is a few dB louder than the input rather than equal to it, because neighbouring bands overlap and add. One voice per channel of the input, so a chord goes through as a chord. In `harmonic` the bands stand on the partials of `pitch` and take its voices in turn, so what passes is a chord rather than a spread.

How loud its input is in each band, one band per channel. The half of a vocoder that listens: wire `out` to `BandFilter.gains` and the shape of this signal lands on that one. Every channel of the input is heard as one signal. In `harmonic` the bands stand on the partials of `pitch` and take its voices in turn, so what it measures is a chord rather than a spread.

An echo, one line per channel, at a delay that may move while it sounds.

An ADSR in [0, 1] over `gate`, one voice per channel of it.

Its input one block late — the one way a loop closes. It runs first each block, reading what its producer left in the last one.

A resonant state-variable filter, low, band or high, at audio-rate cutoff.

Every partial moved by the same number of hertz, which no interval survives.

Its input times `gain`; the wires into `input` sum.

A texture crossing into the audio plane. Its texels are read in scan order, row 0 first, one sample per texel — so the picture's SIZE is its length, and a frame arrives whole and loops until the next one does. The inbox holds one second of samples, so a picture past about 435 square does not fit and is dropped: this crossing is for a modest one.

Hold everything under a ceiling. One gain across every channel, so nothing leaves above it and the picture holds.

A MIDI port as signals. Per voice a gate, a pitch in volts per octave (C4 is 0) and a velocity in [0, 1]. A note lands at the start of the next block.

Many channels become few, each one placed across the field it lands in.

Noise in [-1, 1], white or pink, on as many channels as are asked for.

An oscillator in [-1, 1], one channel per channel of `pitch`.

A pitch in volts per octave pulled to the nearest note of a scale. A named scale is a preset; `custom` builds any scale from a stacked generator, the harmonic series, or a chosen subset of an equal division, read from any of its modes.

A room around the sound. Eight delay lines fed back through each other, out in stereo.

A signal frame crossing into the audio plane. As a `waveform`, a `[C, T]` frame with `sfreq` enters as `C` audio channels, resampled to the rate; one with no `sfreq` enters one sample per sample. The newest frame loops until the next one takes over at its end, so frames on time play back to back and a late one never leaves a gap. With `mix`, the `C` rows play together as one channel, their mean. `low..high` are the values that are full scale, and `smoothing` crossfades one frame into the next. As an `oscillator`, an `[n]` frame is n sines at those pitches, Hz or volts per octave by `pitch`, and a `[2, n]` frame n sines at row 0 with row 1 as their phase in radians; their mean is one channel.

Its input with a rate limit. A step becomes a ramp, a gate an envelope, a knob a glide.

the audio plane as a running picture The door in from a stream, which has a history where a frame has none: every render leaves a column standing and the picture walks left. `audio/mode` says what a column holds — the band its samples span, the frame itself stacked down it, or, on a trace that fades instead of walking, two channels against each other. Set common/width and height, or it is 1024 square.

soften an image or spread it along a path Gaussian weights the center; box averages a square; disk averages a circle. Directional follows angle in degrees (0 is horizontal). Radial rotates about center x/y; zoom moves toward and away from that center. Radius is the maximum offset as a fraction of image height, or a fraction of a turn for radial, or a scale change for zoom. Gaussian uses radius as three standard deviations. Quality sets 5, 9, or 17 samples per axis or path; higher quality reduces gaps at large radii but costs more GPU time. Frame edges are extended. Colors are averaged with alpha weights; radius zero passes the input through.

two textures into one A is the foreground and B is the background. Under puts B over A. Subtract is B - A; divide is B / A (zero divisors give zero). Minimum and maximum compare each RGB channel. In keeps A inside B's alpha; out keeps A outside it; atop keeps B's alpha; xor keeps non-overlapping parts. Color modes blend where the inputs overlap and use source-over alpha. RGB is not clamped, except in color dodge/burn. Blend fades the result back to B with alpha-correct interpolation.

one colour everywhere The simplest source there is: every texel takes the four channels below.

push the input around by a map The map's red and green channels are the two directions, with 0.5 as no push.

Wolfram's one-dimensional automaton, drawn as it scrolls One row of cells, one rule number from 0 to 255, and every generation pushed down the screen. 30 makes noise out of one cell; 110 is a computer.

the previous tick's input The one node a loop closes through: it reads its input as the last tick left it, so a chain can build on what it drew.

magnets that agree with their neighbours, against the heat Drag temperature through about 2.27 and the whole grid changes character: ordered below it, noise above, and long tangled domains right at it.

a continuous cellular automaton Life's smooth relative: a ring-shaped neighbourhood and a growth curve instead of a birth rule. Rings is the kernel's own shape and the widest knob here — one ring gives worms, three gives stars and cells. Radius is the ring as a fraction of the frame, so the creatures are the same size at any resolution. At full density the frame is a soup; lower it and separate colonies grow into the black, some of which die.

brightness, contrast and gamma Gain scales, offset shifts, gamma curves, and invert flips what comes out. Alpha is left alone.

a cellular automaton that keeps its own grid The rule decides what lives; density and seed set the first generation. The grid is the node's own size, so a small one gives large cells.

recolour through a palette One channel of the input reads across the palette, left to right.

Scale and shift texture channels, then remap their range. The order is (input + pre_add) * multiply + post_add, followed by range mapping. RGB leaves alpha unchanged; alpha leaves RGB unchanged; RGBA applies the same math to all four channels. A zero-width source range gives to_low. Reversed ranges are supported. Bounds use the sorted target endpoints: clamp holds values at the edges; wrap repeats the range; fold halves or doubles positive values into a positive range, as in signal Math. Fold ranges narrower than an octave can leave values outside. Values are not clamped unless clamp is selected.

a cellular automaton whose rule is a small network Twelve channels per cell. Each one sees itself, the slope around it and the curvature, and a learned two-layer rule says what to become. Train one against a folder of images with `training/style_ca.py` and wire the `[1, N, 4]` weights it writes into `weights`; the hidden width is read from the array's own length. With nothing wired it draws its own rule from `seed`, which is a texture nobody trained.

noise, in four kinds Period is how far apart the peaks are, harmonics how many finer layers ride on top of them, and roughness how loud those layers are. Speed drifts the field, x and y pan across it. Brightness and contrast are Level's job.

a gradient between two colours The angle turns the gradient: 0 runs left to right, 90 top to bottom.

two chemicals that spread and eat each other The Turing pattern: spots, stripes, worms and mitosis, all out of the same two numbers. Feed and kill are the pair worth dragging.

grains pile up until the pile knocks itself over Self-organized criticality: nothing tunes it, and it settles by itself at the point where one grain can start an avalanche of any size.

one shape on transparent black Size is the width across as a fraction of the frame, and soft is how far the edge fades.

a signal frame as a texture The door in from the signal plane. `signal/mode` says what the frame becomes: its own texels — [N] is one row, [H, W] is gray, [H, W, C] keeps the channels it has — or the line plot or the trajectory a viewer draws of it, on transparent ground so it composites. A texel is the value on the range, through the colormap where the frame has one channel. A [C, N] frame is C series; a trajectory pairs the channels, one against the other. Set common/width and height, or the texture is the frame's own size.

the plane divided, and the picture that divides it One tessellation, in four geometries. Wallpaper folds the plane by one of the seventeen periodic symmetry groups. Kaleido folds it by a triangle of mirrors, and the three angles decide whether the tiling lives on a sphere, on a plane or in Escher's circle limit — sweep them and the curvature sweeps with them. Quasi lays n grids across each other: two or three of them cross into a lattice, and five never repeat. Mosaic hands the picture its own cells and moves them, one relaxation step a frame, until they sit where the edges, the colours or a wired guide say they should. Escher is the page that turns a division into a creature: a displacement field the group carries with it, so the tiles interlock however far they are pushed. Fit blends that field into the picture's own gradient, so the outline learns the image. Morph makes the field drift across the frame and the tiles change shape as they go, still interlocking, which is what a parquet deformation is. Gestalt is where the pattern stops being geometry: figure trades the two hands of a tile, flatten takes each tile's one colour, contour draws the seam and tint tells the tiles apart. Amount holds the tiling exact on one harmonic however far it is pushed. On several, past about three quarters it begins to fold tiles through each other, which is a look and not an error.

brightness to black and white Soft widens the step into a ramp around the level.

move, turn and scale the input Outside the frame it is transparent black, or the frame repeats when tile is on.

Enlarge an SDR image on the GPU. Set common/width and common/height to the output size. FSR 1 and NIS preserve edges and sharpen existing detail. They do not reconstruct detail with AI. Input RGB must be in 0..1. Alpha uses linear sampling. Smaller output dimensions use linear sampling.

a membrane that rings The wave equation on a grid: ripples spread, meet, interfere and fade. It keeps two frames of history, because a wave needs to know where it was going.

show this texture in a window on the machine goofi runs on The window is the frame's own size — set common/width and height to resize it. It stays a normal node: its output is the same texture, so a viewer or another node can read it too.

Frames from a capture device or a video file.

A connectivity matrix over channels. Phase, amplitude and plain statistical couplings, all as `[C, C]`.

Replay an EEG recording at its own rate, as if it were live.

Band power per channel, delta to gamma. Absolute, or as a share of the whole spectrum.

Filter fresh EEG chunks continuously before the rolling PSD buffer. Preserves channel labels, units and sample rate. Uses a causal fourth-order Butterworth bandpass and Q=30 mains notch, retaining SOS state across chunks. Startup is initialized from the first sample and withheld for two seconds. Wire directly from LslIn, never from an overlapping rolling buffer. No clipping, normalization or automatic rereferencing is applied.

Capture each window once; use Buffer to set the window length.

FOOOF: the aperiodic 1/f slope and the peaks that rise above it.

Clustering, path length, centrality and assortativity of a connectivity matrix. Threshold it with `density` first: a complete graph has nothing to say.

Re-reference an EEG frame. Average, median, one electrode, a neighbour-difference Laplacian, or a bipolar chain.

DFA exponent: how far a signal remembers its own past.

Fractal dimension: how much the trace fills the plane. 1 is a smooth line, 2 a trace that fills it.

Hjorth mobility and complexity: mean frequency, and distance from a sine.

LZ76 complexity: how much a signal repeats itself.

Permutation entropy: disorder in the ORDER of neighbouring samples.

Sample entropy: how rarely a pattern that recurred keeps recurring.

Spectral entropy: how flat the power spectrum is, tone to noise.

SVD entropy: how many independent components the signal's history spans.

c1 and c2: how rough a thing is, and how much its roughness varies. c2 near 0 is monofractal; more negative is more multifractal.

Zero crossings: how often the signal changes sign over the window.

A dynamic EQ whose bands are a signal's own spectral peaks. Wire `Peaks` in through a SignalIn: raised by `shift` octaves the peaks are where the bands sit, and left alone they are how fast the bands sweep.

Show an RGB palette as exact swatches, hex labels, and a blended ribbon. Connect BioColors.rgb, or any normalized [colors, 3] RGB array, to input. The display shows up to 16 finite colors. The ribbon interpolates between them; it does not change the swatches. Output is a normalized RGB image.

Emit successive ratios, with an independent hold and glide in each step. Sequence order is retained. A glide occupies the end of each step and joins its ratio to the next in log frequency. The loop joins the last to the first. Ping-pong reverses without repeating its endpoints. Pause holds the current position; reset returns to the first step. Editing ratios or direction also restarts. A clock source change or backward clock jump re-anchors at step one. Keep anchor ratios outside the moving range to avoid component crossings in downstream nodes that sort or merge equal frequencies. transition contains the two endpoint ratio rows and their eased mix in metadata. Connect it to HarmonicModes.transition for smooth plate mode motion. chord.state selects a single ratio or the full anchor chord; its endpoint amplitudes are uniform and phases are zero.

Morph tunings, phases, and component counts; share the result across media.

Keep component fades when one harmonic frame drives sound and geometry.

A palette from a signal's peaks or from a tuning. Inputs: input peaks in Hz, or ratios when `source` is `tuning` amps optional — the amplitudes beside those peaks, as `Peaks` emits them Outputs: rgb one row per degree, red green blue in 0 to 1. Wire this to an `image` viewer lightness per degree, 0 to 1 chroma per degree, how saturated — 0 is grey hue per degree, in degrees around the circle hex the same palette as text, for a viewer or an agent to read

Which elements' spectra stand in the same relations as a signal's peaks. Inputs: input peaks in Hz, as `Peaks` emits them amps optional, and read by `method` `tuning` alone Outputs: elements one entry per element kept, its score per row of input scores the same scores as numbers, ranked, for binding or plotting ranked the element names in that order, so a reader can label the scores categories what each ranked element is — a noble gas, a lanthanide — in the same order

A scale's intervals as euclidean rhythms. Inputs: input a tuning: ratios inside an octave, as `Tuning` emits them Outputs: patterns one row per rhythm, 1 where an onset falls and 0 where none does steps how many steps each row spans, so a row can be read without counting its padding

An evolving atlas of power-weighted harmonic activation and history. Activation is supplied by HarmonicSpectrum: kernel times normalized power outer product. Color uses a labelled logarithmic scale with a slowly decaying peak ceiling. Matrix values themselves are never rescaled. Connect HarmonicSpectrum.analysis to analysis. All panels use one window. display/channel selects a named channel, or a row number for unlabeled data. Refresh the channel list after connecting a source or changing its channels. Connect dashboard to graphics:SignalIn in texture mode, or an image viewer.

A signal's harmonicity spectrum, peak frequencies, and complexity. Input: input raw time series with sfreq metadata; the last axis is time. Use Buffer for at least int(sfreq / precision) samples per row. Short windows wait; flat or non-finite rows return NaN. Connect peaks to Tuning or Harmonicity. peakValues contains harmonicity scores, not the power in dB used by Tuning's diss_curve method. Outputs: analysis one table with all outputs below from the same input window; connect directly to HarmonicObservatory.analysis spectrum H(f), with frequency labels on the last axis freqs the shared frequency grid in Hz, shape [F] peaks peak frequencies in Hz, shape [..., n_peaks] peakValues H(f) at each detected peak, shape [..., n_peaks] matrix frequency-pair similarity, shape [..., F, F] activation matrix * power[:, None] * power[None, :] power min-subtracted PSD normalized to unit sum, as used by H(f) waveform the exact analysis input window harmonicity mean H(f), one value per input row complexity flatness, entropy, spread in Hz, and Higuchi dimension

Harmonic similarity, Tenney height, consonance and subharmonic tension. Inputs: input peaks in Hz, as `Peaks` emits them Outputs: harmsim 0..100, higher is more consonant. The mean harmonic similarity of every pair: how nearly the peaks form a simple whole-number ratio. tenney Tenney height, higher is MORE complex. The log of the ratio's numerator times its denominator, so it grows as the fractions get uglier. cons 0..1, higher is more consonant. The mean consonance of the peak pairs that pass `cons_limit`. subharmTension Higher is more tense. How badly the peaks fail to share a common subharmonic within `delta_lim`.

Play a tuning from a MIDI keyboard: one voice per key, one step per key. Inputs: input a tuning: ratios inside an octave, as `Tuning` emits them notes `signal:MidiIn`'s `notes` — 128 slots, the note number is the INDEX and the velocity the value Outputs: voices the whole keyboard in one wire: pitches then velocities, the layout a plugin's `voice` input reads — cross it with `audio:SignalIn` and that is the only cable pitch volts per octave, zero at C4 — reference this from `voice.pitch` gate 1 while the key is held velocity how hard it was struck, 0 to 1 freq the same pitch in Hz, for reading rather than playing

The dominant spectral peaks of a signal, and their amplitudes. Inputs: input a RAW time series. The last axis is time, and `sfreq` must be in the frame's metadata Outputs: peaks the loudest frequencies, in Hz, `n_peaks` wide and NaN-padded amps each peak's power in dB — normally NEGATIVE, and larger means louder

A scale's degrees as simultaneous cycles on one grid. Inputs: input a tuning: ratios inside an octave, as `Tuning` emits them Outputs: voices one row per degree, 1 where an onset falls and 0 where none does coincidences per grid position, how many voices strike at once labels what each voice is, in the construction's own words cycle how many positions the grid holds, so a player knows the loop length

Walk a rhythm pattern at a tempo and emit its gates. Inputs: input a pattern: `[voices, steps]`, or one `[steps]` row, as the rhythm nodes emit Outputs: gate one row per voice, 1 while its onset sounds and 0 otherwise step which position of the grid is playing, counted from zero phase how far through the current step, 0 to 1, for anything that wants to slide

Hold a tuning, and take a new one only when it is related enough to the last.

A tuning as continuous, bindable synth controls. Inputs: input a tuning: ratios inside an octave, as `Tuning` emits them gate optional scalar or column of gates for the selected partials. Positive values sound a voice; missing input sustains all voices. Outputs: partials the ratios as frequencies over `base_freq`, in Hz amplitudes per partial, 0 to 1, normalized so the loudest is 1 weights per partial, how consonant it is against the rest, 0 to 1 brightness the amplitude-weighted centroid, 0 to 1 across the partial span — the one to bind to a filter cutoff spread how far the degrees sit from simple just ratios, in cents against `spread_span`, 0 to 1: a just scale is 0, a tempered or irrational one higher. Binds to detune, unison or an inharmonic control harmonicity the mean consonance of the whole set, 0 to 1 pitch selected partials in volts per octave, zero at C4; [voices, 1] gain selected amplitudes divided by their sum, then gated; [voices, 1] gate selected voice gates, with unused voices off; [voices, 1] voices pitches followed by gated velocities; [2 * voices, 1], for VST voice Use SignalIn in direct mode for pitch, gain, gate, and voices. A native patch is Osc -> Gain -> Mixdown -> AudioOut, with pitch and gain references. The VST voice cable plays the partials as notes, not as one custom wavetable. Select one analysis row before binding brightness, spread, or harmonicity to a plugin parameter. Those controls are normalized to 0..1; native filter pitch and other physical units need an explicit range mapping.

The ratios between a signal's peaks, as a scale inside one octave. Inputs: input peaks in Hz, as `Peaks` emits them amps optional, and REQUIRED by `method` `diss_curve` — the amplitudes beside those peaks Outputs: tuning the scale's ratios, NaN-padded to the widest row in the batch

The pairwise consonance of a scale's degrees. Inputs: input a tuning: ratios inside an octave, as `Tuning` emits them Outputs: matrix the full `[N, N]` grid, symmetric, for a viewer to draw metricPerStep one number per degree — the grid's column means — which is what a param follows when you want each scale degree to drive something of its own metric one number for the whole scale: how consonant this tuning is overall

The most consonant subset of a scale, as a mode. Inputs: input a tuning: ratios inside an octave, as `Tuning` emits them Outputs: reduced the mode's degrees, always `n_steps` wide and NaN-padded

Export a tuning or explicit partials as a Vital oscillator preset. Inputs: input tuning ratios; use this OR the partials/amplitudes pair partials frequencies in Hz, as TimbreControls emits them amplitudes linear amplitudes aligned with partials, not power in dB signal optional raw biosignal for ensemble, with sfreq metadata Outputs: path last successful preset path, or the ensemble directory files paths of all presets, settings companions, and the ensemble manifest Select a tuning row with preset/row. Each write pulse uses the latest frames. Load the .vital file through Vital's preset browser. It supplies the sound; MIDI or a voice cable must still supply the notes. bell changes the envelope and effects; a periodic wavetable does not retain exact inharmonic pitches.

A dynamic EQ whose bands are a signal's own spectral peaks. Wire `Peaks` in through a SignalIn: raised by `shift` octaves the peaks are where the bands sit, and left alone they are how fast the bands sweep.

Curves, interval graphs, fractals, meshes, plates, and wave fields from one chord. Coordinates retain their physical domain. The sole geometry ARRAY carries the selected method and its connectivity. Changing methods replaces the complete frame.

Map harmonic ratios to Chladni modes and interpolate two mode structures. Use separate input/target harmonic frames and mix, or a single transition ARRAY carrying endpoints and mix metadata. RatioSequence.transition supplies the latter so a new step's endpoints and its mix reset remain synchronized. Endpoints map to integer modes first; intermediate coordinates are continuous visual fields. Connecting both input routes reports an error. Fields interpolation keeps endpoint wavenumbers fixed and only blends their weights; this removes the corner-anchored expansion of coordinate motion.

Apply Biotuner transport operators to an existing scalar geometry field.

Blend scalar fields, curves, or meshes with matching connectivity.

Measure geometry size, field structure, connectivity, and method-specific features.

Render geometry, camera controls, harmonic components, and measurements.

GPU rendering of HarmonicGeometry.geometry or GeometryBlend.geometry: curves, points, graphs and triangle meshes. Fixed orthographic view, transparent background, antialiased lines and depth-tested matte surfaces. Coordinates retain their domain: set radius to fit the geometry. Cost scales with pixels times primitives; start at 256 square. Fields use HarmonicInk instead.

A projected 3D Lissajous trace from HarmonicMorph.harmonic. The first three selected components drive x, y, z. Frequencies remain continuous over a fixed exposure; the curve need not close. Phase comes from the harmonic frame. Start at 256 square; samples controls fragment cost. A high frequency or long duration needs more samples. No hidden clock drives the geometry.

Chladni displacement and nodal density from Biotuner modes. Wire HarmonicModes.modes to modes and HarmonicMorph.harmonic to harmonics. For the cymatics notebook, select chord pairs in HarmonicModes, symmetry 1 here, output nodal, and density_symmetry d4_max. Whole-chord pairwise cosine products become exp(-w²/σ²), then eight square density transforms are united by maximum or averaged. D4 never changes signed displacement. Sigma is explicit, initially 0.05. approach 1 evaluates open directional waves. Fractional modes and field blends are visual transitions, not closed-plate eigenmodes. Signed output uses normal HarmonicInk; density output needs Ink style density or Relief input_kind density. A displacement buffer adds one graphics frame of latency without accumulation.

Color and contours for a signed harmonic field. Wire HarmonicChladni.out to input, or HarmonicGeometry/GeometryBlend/HarmonicTransport.geometry directly to geometry. A valid geometry array takes precedence over the texture input. The raw field is unchanged. BioColors.rgb can feed palette directly as an [N,3] array. Alpha preserves domain masks. range is fixed, so morphs do not silently change their contrast.

Accepts a signed input texture or a canonical field ARRAY on geometry; a valid geometry input takes precedence. Draw a harmonic field as grains, living textures, or sculpted material. Connect HarmonicChladni.out to input. Choose any two textures and morph their surface detail, density, color, and light response. Sand, dunes, lichen, coral, cells, spores, pollen, and plankton join jade, brushed metal, woven silk, and porous stone. Organic textures follow the field with small rough features and restrained highlights. A height-field ray march gives parallax and shadows. Mirrored extension fills the view. This is a stateless visual mapping: grains and cells are procedural features, not tracked particles or a biological simulation. Drive texture_mix separately from upstream mode, phase, or tuning changes. An absent or masked field shows the background.

Persistent ink carried by a harmonic flow field. Wire HarmonicTransport.geometry to flow. Seeded ink is advected by that vector field and by the curl of its own slow memory. There is no hidden time animation. rate 0 freezes the state; reset seeds while held true. diffusion can eventually smooth the image, so injection is available as an explicit control. Output red is ink, green is memory, blue is departure; use HarmonicInk in magnitude mode to color it.

The classical chaotic systems. Six flows and four maps, each on its own canonical constants — a source of motion that never repeats and never jumps.

the orbit a chaotic system draws, on a turning stage The trace a phosphor screen would leave: every point the model reaches is painted and everything already there fades. x across, z up, y into the screen, and `spin` turns the whole figure. Wire the model's `out`; in `value` mode each tick is one dot, and in `block` mode the block is a continuous path.

A random Boolean network, frozen or chaotic on one knob. Every unit reads a few others through a rule drawn once; `activity` says how much of the network is still changing.

the space-time diagram a random Boolean network is judged by One row per unit and one column per tick, oldest at the left. A unit that is on but never changes is grey — the frozen core — and one that keeps flipping burns amber, which is the whole difference between the ordered side of the Kauffman transition and the chaotic one. More units than rows fold into a band each.

Avalanches of activity, tuned to the critical point. The neuronal-avalanche model: `avalanche` reports the size of each cascade once it has finished, and at a branching ratio of 1 those sizes follow a power law.

the cascades a branching network throws, and how big they got One row per unit and one column per tick, oldest at the left, with every column carrying the colour of the avalanche running through it — dim red for a small one, pale yellow for a network-wide storm. The activity profile runs along the bottom. Wire `state`, `activity` and `avalanche`.

An associative memory that completes what it is shown. Store patterns, cue it with a fragment, and `overlap` says which memory it settled into.

an associative memory's state as the picture it is The state vector folded back into a grid of cells, cool for -1 and warm for +1, with the overlap against each stored memory as a strip of bars underneath. Wire `state`, and `overlap` for the strip. `columns` is 0 for as square a grid as the width allows.

Coupled phase oscillators that fall into step. Each runs at its own natural frequency and is pulled towards the others; `order` says how synchronised they are, from 0 to 1.

the phase circle a ring of oscillators is read off One dot per oscillator at its own phase, counter-clockwise from the right, and the order vector out of the middle: its length is how synchronised they are and its heading is the mean phase. Wire the model's `phases`; a `block` frame is read at its newest step. Past 256 oscillators the picture samples them.

Neural populations, wired into a network. Each is a whole population as one variable; a connectome on the `connectivity` input makes the set a whole-brain model.

Nonlinear oscillators with an amplitude of their own. Five models on one set of knobs — a limit cycle, an excitable neuron, a normal form, a double well and a driven pendulum.

Slime-mould agents growing a transport network. Each follows the trail it and the others left; `trail` is a field an image viewer or `SignalIn` draws directly.

the trail a slime mould leaves, lit the way it is usually shown The field through a ramp with a gamma under it, which is what makes the faint filaments visible at all; the agents themselves ride over it as dots. Wire `trail`, and `positions` for the overlay. The overlay walks at most 512 agents, and a run of more than 8192 does not reach the engine at all.

Populations that rise, crash and cycle. Predator and prey, an epidemic running its course, and the map that folds one population into chaos.

A few qubits, simulated exactly, with the patch turning the knobs. `angles` drives every rotation; `probabilities` is what a measurement would find, and `entropy` is how entangled the qubits have become.

the two pictures a few qubits are read from A Bloch sphere per qubit — x across, z up, and y into the screen, which warms and widens the head as the vector comes towards you — over the statevector as a bar per basis state. Wire `bloch` and `probabilities`.

Trains a linear readout on a live state, one step at a time. Wire a reservoir to `state` and what it should say to `target`; recursive least squares does the rest, and `error` is how wrong it still is.

A pool of randomly wired units that rings when driven. The echo state network: the pool is never trained, only read — wire `Readout` to it to turn what it remembers into a prediction.

the activity carpet an echo state network is read from One row per unit and one column per tick, oldest at the left, cool for a unit pushed negative and warm for one pushed positive. A pool with a long memory holds its stripes for many columns; one with a short memory does not. More units than rows fold into a band each.

A spiking network laid out in space, with conduction delays. Neurons wire to their neighbours, a spike takes time to arrive, and `weight` is the knob between silence and a storm.

the raster a spiking network is read as, scrolling One row per neuron and one column per tick, oldest at the left: spikes as marks over the membrane potential as heat. The picture is the node's own, built up tick by tick, so a `value` frame is enough — a `block` frame folds to the strongest sample it holds. More neurons than rows fold into a band each.

Particles with a rule between every pair. Flocking, alignment, gravity, oscillators that swarm, and asymmetric attraction between colours — one integrator, five rules.

the particles a swarm is made of, where they are and where they are going A dot per particle in the model's own unit box, with a streak along its velocity. Wire `positions`, and `velocities` and `phases` for the streak and the colour. A third column is depth: it shrinks and dims what is far away. Past 512 particles the picture samples them.

How every part of the picture moved since the picture before it.

Find named things in a picture, and say where each one is.

Track a body, hands or a face in a picture, and how fast each point moves.

Cut the person, or one named thing, out of the picture as a soft mask.

the figure a set of landmarks makes, drawn on clear ground Wire `positions` from `PoseEstimation` and it draws what that mode found — a body's bones, a hand's fingers, a face's contours — because `rig` reads the shape from the ROW COUNT and needs telling nothing. Wire `velocities` too for a streak behind each point. Nothing is drawn on the ground, so `graphics:Composite` puts it straight over the picture it came from. A frame with no rig it knows, a swarm or a set of boxes, is drawn as its points alone.

Run a trained generator, steering its latent from the patch.

Run any ONNX model on the arrays wired into it.

Learns to drive a continuous action so a reward keeps rising, and never settles. Wire a feature of the signal to `observations`, the feature you want raised to `reward`, and `actions` to whatever sets the stimulus. `diagnostics` is how stagnation is SEEN before it costs a session: the average reward, how surprised the agent is, and three plasticity readings.

Hold a `.npy` or `.npz` array on the wire, reloading it when the path changes.

Edit a video or graphics stream. The 16 GB preset trades frame rate for memory.

Load PNG, JPEG, WebP and other Pillow image formats from an absolute file path.

Restore and upscale RGB images. This can smooth fine textures and change detail.

Sixteen EEG features drive liquid pigments, morphing and color. Inputs 1-8: normalized LZ; 9-16: normalized Higuchi dimension.

Recursive jeweled filigree, from icy spiral lace to enameled paisley. Each recursion level deposits its own ribbon, beads and lace on top of the coarser ones, so the frame fills with nested ornament. topology x fold x symmetry x palette are a combinatorial space of forms; style blends the cold filament look (0) into gold-and-teal enamel (1). Set wander to 0 for a still image.

Inception: living iridescent thought-forms unfolding from within. Inspired by Besant and Leadbeater's Thought-Forms (1901), especially the meditation and music plates. Nested luminous membranes continually bloom, curl and dissolve. Stateful reaction-diffusion bends and illuminates the membranes, with vortices, orbital drift and peristaltic waves. Speed controls metabolism; morph changes the organism; intricacy adds fine ribs; iridescence controls interference colour. Every artistic parameter has its own GPU sine LFO: lfo_rates are Hz and lfo_depths are peak excursions in parameter units; zero depth stops that modulation. Base controls remain editable. Motion speed uses an integrated phase to avoid acceleration from multiplying a changing speed by elapsed time.

Six nested scales of local agreement and distant inhibition, drawn in ink. A visual metaphor for thought, not a brain model. Equal rules at geometrically spaced radii create competing domains. Activity advects through its own memory gradient; memory slowly follows. Finite resolution bounds the scale range. The field and its colouring are one node here: the `structure` and `motion` groups shape what happens, and `tone`, `palette` and `texture` decide how it is drawn.

Nested fBm pigments and layered refractive pools. Choose fBm or refractive pools. Nine palettes use the internal warp fields for secondary pigments and iridescent color. Pool brush controls create a moving ripple; optics controls depth, refraction, dispersion, absorption and lighting. Refraction is a layered screen-space approximation. Fractal selects noise basis, octave spacing and folds. Geometry stretches, twists or mirrors the domain. Warping controls the two displacement scales and directions. Structure adds terraces and marble bands. These shape controls also feed the refractive pool.