Graph Editor

Custom Shaders · GPU · No Dev Account Required

Custom Metal Shaders

Write a Metal fragment function and run it as a generator node. VKO1 injects beat phase, BPM energy, time, jog wheel value, and resolution automatically — no boilerplate required. Start from a one-tap boilerplate, write code directly inside the app, or import a .metal file from your Files app.

No Apple Developer Account required. Shaders compile at runtime using Apple's Metal API inside the app's sandbox — exactly the same as built-in generators. No Xcode, no provisioning profile, no external tools needed.

Three Ways to Get Started

1 — New Shader from Scratch

Tap New Shader from Scratch in the node palette. VKO1 instantly generates a working boilerplate shader, compiles it, and adds the node — no file needed. Select the node and tap Edit Shader Code to customize it.

2 — Write & Edit Inside VKO1

Select any Custom Shader node and tap Edit Shader Code in the inspector. The in-app editor opens with the current source. Edit and hit Compile — the node updates live. Compile errors appear in a red banner; tap the copy icon to copy them to clipboard.

3 — Import a .metal file

Write your shader in any text editor (Notes, VS Code, Textastic), save as .metal, and tap Import .metal File from the node palette. VKO1 detects the function name, compiles, and adds the node automatically.

Required Function Signature

Your file must contain exactly one fragment function. The name can be anything — VKO1 detects it automatically.

fragment float4 your_shader_name(
    VertexOut in [[stage_in]],
    constant GeneratorUniforms &u [[buffer(0)]]
) {
    // u.time, u.beatPhase, u.energy, u.resolution, ...
    float2 uv = in.uv;
    return float4(uv, u.beatPhase, 1.0); // your logic here
}

Available Uniforms — `GeneratorUniforms`

All fields are injected automatically. Access them via u.

u.time

Elapsed seconds since launch. Use for animation.

u.beatPhase

0 → 1 ramp that resets on every beat. Drives beat-sync pulses.

u.beatStrength

Normalized confidence of the last detected beat. 0–1.

u.energy

Broadband audio energy. Peaks on loud hits. 0–1.

u.resolution

float2 — render target size in pixels.

u.speed

Speed scalar — defaults to global BPM speed, but now connectable via the Speed pin. Wire Bass or LFO to a node's Speed pin to override per-node.

u.reactivity

The Reactivity pin value (0–1). Scale energy by this.

u.complexity

The Complexity pin value (0–1). Use as a detail/scale control.

u.colorPalette

int — index 0–32 of the selected palette. Use for custom palette logic.

u.jogValue

Jog wheel position (-1 → 1). Map to rotation, offset, or warp.

u.pad1

Reserved float for future use. Always 0.

Minimal Working Example

// beat_rings.metal — paste into any text editor, save as .metal, import into VKO1

#include <metal_stdlib>
using namespace metal;

// VKO1 injects VertexOut + GeneratorUniforms automatically — no need to redefine them here
// GeneratorUniforms includes: time, beatPhase, beatStrength, energy, resolution,
// speed, reactivity, complexity, colorPalette (int), jogValue

// --- Cosine palette helpers (same formula used by VKO1 built-in generators) ---
float3 cosine_palette(float t, float3 a, float3 b, float3 c, float3 d) {
    return a + b * cos(6.283185 * (c * t + d));
}

float3 get_palette_color(float t, int idx) {
    switch (idx) {
        // Cyberpunk, Neon, Fire, Ice, Nature, Synthwave, Mono, Rainbow
        case 0:  return cosine_palette(t, float3(0.5), float3(0.5), float3(1.0,1.0,1.0), float3(0.00,0.10,0.20));
        case 1:  return cosine_palette(t, float3(0.5), float3(0.5), float3(1.0,1.0,0.5), float3(0.80,0.90,0.30));
        case 2:  return cosine_palette(t, float3(0.5), float3(0.5), float3(1.0,0.7,0.4), float3(0.00,0.15,0.20));
        case 3:  return cosine_palette(t, float3(0.5,0.5,0.8), float3(0.4,0.4,0.2), float3(1.0), float3(0.00,0.33,0.67));
        case 4:  return cosine_palette(t, float3(0.5), float3(0.5), float3(1.0,0.7,0.4), float3(0.30,0.20,0.20));
        case 5:  return cosine_palette(t, float3(0.5), float3(0.5), float3(2.0,1.0,0.0), float3(0.50,0.20,0.25));
        case 6:  return cosine_palette(t, float3(0.5), float3(0.5), float3(1.0), float3(0.0));
        case 7:  return cosine_palette(t, float3(0.5), float3(0.5), float3(1.0), float3(0.00,0.33,0.67));
        // Toxic, Blood Moon, Electric, Lava, UV, Candy, Matrix, Inferno
        case 8:  return cosine_palette(t, float3(0.2,0.6,0.0), float3(0.3,0.5,0.2), float3(1.0,1.5,0.5), float3(0.00,0.05,0.30));
        case 9:  return cosine_palette(t, float3(0.6,0.1,0.1), float3(0.5,0.3,0.3), float3(1.0,0.5,0.5), float3(0.00,0.10,0.30));
        case 10: return cosine_palette(t, float3(0.2,0.2,0.8), float3(0.5,0.5,0.5), float3(1.0,1.0,2.0), float3(0.10,0.20,0.00));
        case 11: return cosine_palette(t, float3(0.6,0.3,0.0), float3(0.5,0.4,0.3), float3(1.5,1.0,0.5), float3(0.00,0.05,0.10));
        case 12: return cosine_palette(t, float3(0.4,0.0,0.6), float3(0.5,0.3,0.5), float3(1.5,0.5,2.0), float3(0.30,0.20,0.00));
        case 13: return cosine_palette(t, float3(0.8,0.4,0.5), float3(0.5,0.5,0.5), float3(1.0,1.0,1.0), float3(0.00,0.15,0.50));
        case 14: return cosine_palette(t, float3(0.0,0.4,0.0), float3(0.1,0.5,0.1), float3(0.5,1.5,0.5), float3(0.0));
        case 15: return cosine_palette(t, float3(0.7,0.4,0.2), float3(0.6,0.5,0.4), float3(1.0,0.8,0.5), float3(0.00,0.05,0.15));
        // Mono Red, Blue, Green, Purple, Amber, Cyan, Pink
        case 16: return cosine_palette(t, float3(0.4,0.0,0.0), float3(0.4,0.1,0.1), float3(1.0,0.3,0.3), float3(0.0));
        case 17: return cosine_palette(t, float3(0.0,0.0,0.4), float3(0.1,0.1,0.5), float3(0.3,0.3,1.0), float3(0.0));
        case 18: return cosine_palette(t, float3(0.0,0.3,0.0), float3(0.1,0.5,0.1), float3(0.3,1.0,0.3), float3(0.0));
        case 19: return cosine_palette(t, float3(0.3,0.0,0.4), float3(0.3,0.1,0.5), float3(0.8,0.3,1.0), float3(0.0));
        case 20: return cosine_palette(t, float3(0.4,0.2,0.0), float3(0.5,0.3,0.1), float3(1.0,0.6,0.2), float3(0.0));
        case 21: return cosine_palette(t, float3(0.0,0.3,0.4), float3(0.1,0.4,0.5), float3(0.2,1.0,1.0), float3(0.0));
        case 22: return cosine_palette(t, float3(0.4,0.0,0.2), float3(0.5,0.1,0.3), float3(1.0,0.2,0.6), float3(0.0));
        // Sunset, Ocean, Vapor, Copper, Aurora, Coral, Midnight, Rust, Hologram, Marathon
        case 23: return cosine_palette(t, float3(0.5,0.5,0.5), float3(0.5,0.5,0.3), float3(1.0,0.7,0.7), float3(0.00,0.15,0.40));
        case 24: return cosine_palette(t, float3(0.0,0.3,0.5), float3(0.3,0.4,0.4), float3(0.5,1.0,1.0), float3(0.20,0.10,0.00));
        case 25: return cosine_palette(t, float3(0.8,0.7,0.8), float3(0.2,0.2,0.2), float3(1.0), float3(0.00,0.10,0.20));
        case 26: return cosine_palette(t, float3(0.5,0.3,0.15), float3(0.4,0.3,0.2), float3(1.0,0.7,0.4), float3(0.00,0.05,0.10));
        case 27: return cosine_palette(t, float3(0.3,0.5,0.4), float3(0.4,0.4,0.4), float3(1.0,1.0,1.5), float3(0.00,0.20,0.50));
        case 28: return cosine_palette(t, float3(0.6,0.4,0.4), float3(0.4,0.3,0.3), float3(1.0,0.8,0.6), float3(0.00,0.10,0.25));
        case 29: return cosine_palette(t, float3(0.1,0.1,0.3), float3(0.3,0.3,0.5), float3(0.5,0.5,1.5), float3(0.25,0.25,0.00));
        case 30: return cosine_palette(t, float3(0.5,0.25,0.1), float3(0.4,0.3,0.2), float3(1.2,0.6,0.3), float3(0.00,0.10,0.20));
        case 31: return cosine_palette(t, float3(0.5), float3(0.5), float3(1.5), float3(0.30,0.20,0.10));
        case 32: return cosine_palette(t, float3(0.45,0.55,0.30), float3(0.55,0.50,0.50), float3(1.0,0.8,1.2), float3(0.00,0.15,0.35));
        default: return cosine_palette(t, float3(0.5), float3(0.5), float3(1.0), float3(0.00,0.10,0.20));
    }
}

fragment float4 beat_rings(
    VertexOut in [[stage_in]],
    constant GeneratorUniforms &u [[buffer(0)]]
) {
    float2 uv = in.uv - 0.5;
    uv.x *= u.resolution.x / u.resolution.y; // correct aspect ratio

    float dist = length(uv);
    float freq = 6.0 + u.complexity * 12.0;
    float phase = dist * freq - u.time * u.speed;
    float ring = 0.5 + 0.5 * sin(phase + u.beatPhase * 6.2831);

    float pulse = 1.0 + u.energy * u.reactivity * 0.5;
    float3 col = get_palette_color(ring * pulse, u.colorPalette); // uses selected palette

    return float4(col, 1.0);
}

📦 17 Example Shaders — Ready to Import

Retro grid, wireframe cube, neon tunnel, digital rain, CRT monitor, laser grid, pixel warp, hex wave, diamond spin, aurora, kaleidoscope, plasma orb, spiral vortex, star warp, voronoi glass, holo HUD, and synth city. All use the full palette system, beat detection, jogwheel, complexity, and reactivity — great for learning how every uniform works.

⬇ Download ExampleShaders.zip Download from Github

Download and unzip on your device
Open VKO1 → long-press or right-click any pad → Create Visualizer from Scratch
Tap the Import .metal button in the top bar (⬇ icon)
Select a .metal file — VKO1 compiles it and adds a Custom Shader node
Connect the node to Output and hit Done
Use the inspector to change palette, complexity, and reactivity

Shader Repos to Adapt

These open-source GLSL/Metal collections are great starting points. Two quick changes make any Metal shader from these repos work in VKO1: rename ProjectedVertex → VertexOut, and prefix uniform fields with u. instead of whatever struct name the original uses. GLSL shaders need conversion to MSL (types, built-ins, and coordinate conventions differ).

iShader (Treata11)

Large Metal fragment shader collection for SwiftUI — noise fields, plasma, aurora, halftone, kaleidoscope, SDF shapes, distortions, and more. All MSL. Uses SwiftUI layer effect signatures, so strip the [[stitchable]] attribute and rewrite the function signature to the VKO1 format. The math is directly portable.

github.com/Treata11/iShader ↗

MSL · Signature rewrite

metal-by-example / sample-code

Warren Moore's Metal sample code from his Metal by Example book. API-first, clean conventions — the best reference for understanding how Metal rendering pipelines are structured before writing your own shaders from scratch. Less about effects, more about getting the fundamentals right.

github.com/metal-by-example/sample-code ↗

MSL · Reference / Learning

ShaderToy (GLSL → MSL)

Thousands of procedural fragment shaders. All are GLSL — convert vec2/vec3/vec4 → float2/float3/float4, rename iTime → u.time, iResolution.xy → u.resolution, replace fragCoord / iResolution with in.uv.

shadertoy.com ↗

GLSL · Conversion needed

Shadertweak (warrenm)

An iOS Metal shader live editor by Warren Moore — write a fragment function and see it render in real time. Includes a set of built-in starter shaders you can browse and copy. The shaders use a very similar single-struct uniform pattern to VKO1's GeneratorUniforms, so adaptation is minimal.

github.com/warrenm/Shadertweak ↗

MSL · Easy to adapt

MetalPetal Shaders

Open-source video filter framework with a large shader library — color grading, chroma key, morphological ops, bloom, vignette. Shaders follow clean Metal conventions. Good source for modifier-style effects if you want to hand-roll an in-graph filter.

github.com/MetalPetal/MetalPetal ↗

MSL · Filter-style

Inferno (twostraws)

~30 MSL shaders by Paul Hudson — procedural generators, transitions, blur variants, and distortion effects. Written for SwiftUI's [[stitchable]] convention. The logic is directly usable; the signature needs rewriting. Replace [[stitchable]] half4 name(float2 position, half4 color, ...) with the standard VKO1 signature, change half4 → float4, and map the explicit float parameters (time, size) to u.time and u.resolution.

github.com/twostraws/Inferno ↗

MSL · Signature rewrite

Book of Shaders (GLSL)

The canonical learn-to-write-shaders resource. GLSL, but every example teaches a concept you then implement in MSL. Covers noise, patterns, shapes, and color — the foundation for writing original VKO1 shaders from scratch.

thebookofshaders.com ↗

GLSL · Learn to write

GLSL → MSL cheatsheet: vec2/3/4 → float2/3/4 · mat2/3/4 → float2x2/3x3/4x4 · mix() stays mix() · fract() → fract() · texture2D() → tex.sample() · gl_FragCoord.xy / iResolution.xy → in.uv

Modifiers · 27 nodes

Modifier Nodes

Modifiers take one texture in, return one transformed texture. The Amount pin (float, 0–1) is exposed on every modifier — connect an Input node to it for animated control. The Speed pin lets you override the global speed per-node. Stack multiple modifiers in a chain for compounding effects.

Amount & Speed pins. Connect a Bass, LFO, or Beat Strength input node to a modifier's Amount pin to animate the effect intensity with the music. The Speed pin on every generator, modifier, and combiner can also be driven by input nodes — wire Bass → Speed to make the shader animate faster with more low-end energy. Example: LFO (square, 2 Hz) → Glitch.amount produces a strobe-glitch that fires at exactly 2 Hz.

Blur

9-tap separable Gaussian blur. Amount controls radius (up to 3% of UV space). Stack two Blur nodes for a wider spread.

Mirror

Horizontal mirroring. Supports hard mirror or blended mode. Fundamental for creating symmetrical VJ compositions.

Kaleidoscope

Radial segmentation with alternating reflection. Param1 sets segment count (2–16). Amount controls blend strength. Works on any generator.

Color Shift

Lateral chromatic aberration — splits RGB channels horizontally. Amount drives the separation distance. Beat-reactive version of a classic lens effect.

Hue Rotate

Full-spectrum hue rotation via Rodrigues RGB-space rotation. Amount drives the rotation angle (0–360°). Connect an LFO to Amount for a continuously cycling palette.

Edge Detect

Sobel operator edge detection. Amount controls edge magnitude threshold. Brilliant before Thermal for a glowing wireframe look.

Posterize

Quantizes color to 2–16 levels. Amount controls the quantization step. Creates stark, graphic poster art from any generator.

Halftone

Print-dot halftone effect with variable dot size. Param1 enables custom dot color, Param2–4 set the RGB values via the inspector's color picker.

Distort

Perlin-displacement UV distortion with beat-reactive boost. Amount controls displacement magnitude. Pushes every pixel in a noise-driven direction.

Wave Warp

Sinusoidal horizontal and vertical waves applied to UV coordinates. Amount drives wave amplitude. Beat pulse doubles the wave height momentarily.

Feedback

Blends the previous frame with the current frame, with a slight zoom on the feedback copy. Creates infinite tunnel-trail effects. Amount controls persistence (0.8–0.98 decay).

Thermal

Maps luminance to a color ramp. Four colormaps: Thermal, Fire, Ice, Neon. Incredible after Edge Detect. Param1 selects the colormap in the inspector.

Chroma Key

Keys out green, blue, or red with a configurable threshold. Useful when compositing external video sources. Param1 selects the key color.

Color Ramp

Maps luminance to a two-color gradient. Amount controls the midpoint of the ramp. A lighter alternative to Thermal when you want a clean bi-color look.

Glitch

Per-row random horizontal displacement with optional RGB split. Beat drives burst intensity. Two styles: Row Shift and RGB Split (Param1). Connect an LFO for rhythmic corruption.

Pixelate

Block pixelation at 2–64 pixel sizes. Amount controls block size. Snaps the image to a low-res grid. Effective at revealing the underlying structure of complex generators.

Saturation

Desaturate or oversaturate the input. 0.5 = original. 0 = grayscale. 1 = fully vivid. Connect a Beat Strength input to slam color in on every hit.

Scanlines

CRT-style horizontal scan lines. Amount controls intensity. Param1 overrides spacing. Beat brightens the scan lines momentarily for a phosphor-pulse effect.

Bloom NEW

Single-pass Gaussian bloom with threshold extraction. Amount controls both the spread radius and the extraction threshold. Beat hits boost the glow intensity automatically. The go-to finish for any neon or laser generator.

Core Image Modifiers NEW

These 7 nodes are powered by Apple's Core Image framework — hardware-accelerated and available on all devices. They expand into distortion, grading, and cinematic effects that go far beyond what a custom Metal shader can do in a single pass.

Twirl NEW

CITwirlDistortion — spirals the image outward from center. Amount controls twist angle (0→4π). Param1 sets the effect radius as a percentage of frame size. Wire Bass to Amount for a kick-driven spin.

Vortex NEW

CIVortexDistortion — rotational warp that pulls the whole frame into a spiral. Deeper and more continuous than Twirl. Wire a slow LFO to Amount for perpetual rotation that builds gradually.

Pinch NEW

CIPinchDistortion — squeeze the frame inward (Amount < 0.5) or bulge it outward (Amount > 0.5). Amount = 0.5 is neutral. Wire Beat Phase to create a lens pulse that breathes on every bar.

Variable Blur NEW

CIGaussianBlur with a soft edge clamp to avoid border artefacts. Amount controls radius (0–50 px). Unlike the Metal Blur node, this operates at full pixel resolution — better for soft-focus and depth-of-field looks.

Color Controls NEW

CIColorControls — three independent sliders in the inspector: Saturation (0→2×), Brightness (−0.5→+0.5), Contrast (0.25→2). Amount is a wet/dry blend with the original. The most versatile color grading node in the graph.

Transform NEW

CIAffineTransform — rotate, scale, and translate the frame. Amount = rotation angle (0→360°). Inspector exposes Scale (0.5–2×) and X/Y Offset. Wire an LFO to Amount for infinite slow rotation without any shader code.

Film Look NEW

8 cinematic photo filter presets: Noir, Chrome, Fade, Mono, Process, Tonal, Transfer, Instant. Param1 selects the preset in the inspector. Amount = wet/dry blend with the original. Stack after Color Controls for full color grading.

2.5D Perspective NEW

A special modifier that rotates the flat shader output in 3D space with perspective projection. The shader stays 2D, but the plane it lives on tilts, spins, and floats in perspective. Three rotation pins (X, Y, Z) are all connectable — wire audio inputs for reactive 3D movement.

Perspective 3D NEW

Rotates the shader quad in 3D with perspective projection. Three float input pins — Rotate X, Rotate Y, Rotate Z — each connectable to Bass, LFO, Beat, etc. Inspector exposes Perspective (FOV strength) and Zoom sliders. Wire Bass → Rotate X and the shader tilts toward you on every kick. Wire LFO → Rotate Y for a slow floating display spin. Stack with Bloom for a dramatic floating-screen-in-the-void look.

Example: Floating Plasma — 2.5D with audio-reactive rotation

GenPlasma

→

ModPerspective 3D

→

ModBloom

→

OutOutput

InpLFO (0.15 Hz)

→ Perspective 3D.rotateX

InpBass

→ Perspective 3D.rotateY

Example: Bloom in a chain

GenNeon Prism

→

ModEdge Detect

→

ModBloom

→

ModKaleidoscope

→

OutOutput

Example: Film Noir — cinematic grading chain

GenNeon Prism

→

ModFilm Look (Noir)

→

ModEdge Detect

→

OutOutput

Example: LFO Spin — infinite rotation via Transform

GenFractal Noise

→

ModTransform

→

OutOutput

InpLFO (0.15 Hz)

→ Transform.amount

Inputs · 11 nodes

Input Nodes

Input nodes produce a single float value (0–1). They have no texture input and no visual output — they only feed float pins on other nodes. Connect them to any float pin: Reactivity, Complexity, Amount, or Mix.

Patching. Think of Input nodes as the modular synthesis section of the graph. An LFO driving a Bloom's Amount is a patch cable. A Bass node driving a Beat Crossfade's Mix means the low end physically controls which scene is showing.

Audio / Performance

Beat Phase

0→1 ramp that resets on every beat. Connect to a Combiner's Mix pin for a parameter that sweeps across every bar. The heartbeat of the system.

Beat Strength

Onset detection strength (0–1). Spikes on transients. Connect to Bloom's Amount or a Modifier's Amount for impact-driven effects that only fire when the music hits hard.

Energy

Overall audio energy, smoothed. Slower-moving than Beat Strength. Good for driving background complexity parameters that breathe with the music rather than snap.

Bass NEW

Average energy of spectrum bins 0–4 (roughly 20–300 Hz). The kick and sub frequencies. Connect to a generator's Reactivity or a Distort's Amount to make the low end shake the image.

Mid NEW

Average energy of spectrum bins 5–15 (roughly 300 Hz–3 kHz). Snare, rhythm, and mid-frequency content. Great for driving Saturation or Wave Warp.

Treble NEW

Average energy of spectrum bins 16–31 (roughly 3–20 kHz). Hi-hats, cymbals, and high-frequency shimmer. Connect to Bloom or Color Shift for high-end sparkle.

Spectrum

The full 32-bin spectrum array. This is a spectrum-type pin, not a float — it feeds spectrum-aware generator parameters directly. Used internally by audio-reactive generators.

Time / Control

LFO

Low-frequency oscillator. Rate: 0.1–10 Hz. Four shapes: Sine, Triangle, Square, Saw. The most versatile modulator — use Square to gate effects rhythmically, Sine for smooth sweeps.

Constant

A fixed value set by a slider (0–1). Use it to lock a parameter at a specific value, overriding audio reactivity entirely. Essential for controlled, stable looks.

Time

The raw time value, growing continuously. Connect to a generator's Complexity to drive it at a fixed speed regardless of music. Wraps through the generator's own time calculation.

Jog Wheel

The current jog wheel rate (–1 to +1). If you have the jog wheel active in VKO1, this outputs its value live. Connect to Hue Rotate's Amount for manual color control during performance.

Frequency split: each band controls a different parameter

InBass

→ Bloom.amount

InMid

→ Distort.amount

InTreble

→ ColorShift.amount

GenVoronoi

→

ModDistort

→

ModBloom

→

ModColor Shift

→

OutOutput

Workflow

Building Your First Graph.

Start from a preset and modify it, or build from scratch. Either way, the workflow is the same: source → shape → combine → control.

Start from a template

Tap the grid icon in the toolbar to open Graph Presets. Templates are pre-wired starting points — load one and explore what's connected before changing anything.

Add your generator

Every graph needs at least one generator. Tap + → Generators to add one. Set its Palette and Complexity in the inspector. Connect its output pin to the Output node to preview it.

Chain a modifier

Add a modifier between the generator and the output. Drag from the generator's output pin to the modifier's input pin. Then drag from the modifier's output to the Output node.

Add modulation

Add a Bass, LFO, or Beat Phase input node. Drag from its Value pin to any float pin on a modifier or combiner. Watch the effect animate in real time in the preview panel.

Validation. VKO1 validates your graph in real time. You'll see an error if the Output node has no input connected, if there are more than 16 nodes, or if a cycle is detected. The Done button is disabled until the graph is valid.

Presets

Built-in Templates.

VKO1 ships with 22 ready-to-use graph templates. Each one demonstrates a different patching technique. Load them in the Graph Presets browser and modify them freely — they won't overwrite the originals.

Layered Plasma

Plasma + Fractal Noise → Blend → Output

Two organic generators blended at 60/40 mix using the Blend combiner in Normal mode. A gentle introduction to dual-generator graphs.

Cyber Terrain

Tron Grid + Vector Terrain → Screen Blend → Output

Screen blend mode makes the grids add together without blowing out. The result is a layered topographic HUD.

Kaleidoscope Cells

Voronoi → Kaleidoscope (6 segments) → Output

Demonstrates the Kaleidoscope modifier's Param1 override for segment count. Try connecting an LFO to Amount.

Feedback Tunnel

Tunnel → Feedback (0.7) → Output

The Feedback modifier retains 70% of the previous frame, creating a trailing ghost tunnel. Increase Amount to 0.95 for extreme smear.

Spectrum Blend

EQ Bars + Spectrum Wave → Add Blend → Output

Add blend mode combines two audio-reactive generators. The result sums their energies without the darker regions cancelling each other.

Thermal Edge

Neon Prism → Edge Detect → Thermal → Output

Edge detection isolates the geometric borders of Neon Prism, then Thermal maps the edge luminance to a fire gradient.

Beat Switch NEW

Laser Web + Neon Prism → Beat Crossfade (Hard Cut) → Output

Hard-cut beat crossfade switches between generators on each beat. Change the mode to Smooth for a gradual transition.

Star Punch NEW

Plasma + Starfield → Luma Key → Output

Dark areas of Plasma are replaced by the Starfield. Adjust Mix (threshold) to control how many stars are visible.

Bass Bloom NEW

Voronoi → Bloom ← Bass input

The Bass input node drives Bloom's Amount directly. Low-end hits bloom the cells outward. Shows the float pin patching workflow.

LFO Glitch NEW

Signal Decode → Glitch (RGB Split) ← LFO (Square, 2 Hz)

A square-wave LFO at 2 Hz gates the Glitch amount. Demonstrates how Input nodes can replace MIDI CC control in the graph.

Pulse Storm NEW

Grid Pulse + Particles → Beat Crossfade (Flash B) → Bloom → Output

The Particles flash in on the downbeat and decay back to Grid Pulse. Bloom sits after the crossfade so both sources benefit from it.

Twirl Plasma NEW

Plasma → Twirl ← Bass input

Bass energy drives the Twirl angle directly. The kick drum spins the plasma field. Try increasing Param1 (radius) for a wider affected area.

Vortex Voronoi NEW

Voronoi → Vortex ← LFO (Sine, 0.3 Hz)

A very slow sine LFO rotates the Voronoi field continuously. The result is a living organism that never repeats exactly the same pattern.

Pinch Pulse NEW

Tunnel Warp → Pinch ← Beat Phase

Beat Phase sweeps 0→1 every bar, driving Pinch from neutral to full bulge. The tunnel lens pulses outward in sync with the music.

Dreamy Haze NEW

Vector Terrain → Variable Blur → Color Controls → Output

Soft Gaussian blur over atmospheric terrain, then Color Controls bumps saturation and contrast. A slow, textural look for ambient sets.

Color Burst NEW

Starfield → Color Controls (max sat) → Bloom → Output

Color Controls cranked to full saturation, then Bloom halos every star. Pure neon — adjust the palette on the Starfield generator to shift the color story.

Film Noir NEW

Neon Prism → Film Look (Noir) → Edge Detect → Output

Noir desaturates and adds filmic grain, then Edge Detect traces the geometric borders. Cinematic black-and-white wireframe.

LFO Spin NEW

Fractal Noise → Transform ← LFO (Sine, 0.15 Hz)

A very slow LFO rotates the entire frame via Affine Transform. The fractal pattern drifts slowly in a way that feels alive but never distracts.

Cinema Blend NEW

Laser Web + Tron Grid → Screen Blend → Film Look (Chrome) → Bloom → Output

The most complex template — 6 nodes. Two generators screen-blend, then Chrome film grading and Bloom finish it. Shows how the CI modifiers slot into a full signal chain.

Bass Rush NEW

Tunnel Warp → Glitch → Bloom → Output ← Bass → Speed, LFO → Glitch.amount

Bass drives the Tunnel Warp's Speed pin — the tunnel accelerates on every kick. A square-wave LFO gates the Glitch for choppy digital breakup. Demonstrates the new connectable Speed pin.

Breathing Cosmos NEW

Starfield + Plasma → Add Blend → Output ← LFO (slow) → Starfield.speed, LFO (fast) → Plasma.speed

Two LFOs at different rates drive the Speed of two generators independently. The slow sine makes stars drift in and out, the faster triangle pulses the plasma. Organic and alive without any audio input.

Floating Plasma NEW

Plasma → Perspective 3D → Bloom → Output ← LFO → rotateX, Bass → rotateY

The plasma floats in 3D space — a slow LFO gently tilts the X axis while bass kicks rotate the Y axis. Bloom finishes it for a glowing floating-screen-in-the-void look. Showcases the new 2.5D Perspective modifier.

Advanced

Power Moves.

Once you understand the basics, these patterns will push your graphs into territory no built-in preset can reach.

Feedback loop from a combined source

Run two generators into a Blend combiner, then put Feedback after the combiner. The feedback now captures the blended image — not just one source. The trails carry both generators inside them.

Use Difference on the same generator twice

Add the same generator type twice — same palette, but one at complexity 0.2 and one at 0.8. Run them into a Difference combiner. You get an entirely new pattern from two identical sources running at different scales.

Displace A with A (self-displacement)

Run a generator into a Displace combiner as both Input A and Input B. The generator uses itself as its own displacement map. This creates recursive warping that changes completely over time.

Lock reactivity with a Constant node

Connect a Constant (value 0) to a generator's Reactivity pin to disable its audio response entirely. Now the generator is a stable texture you can layer other audio-reactive content over.

Bass, Mid, Treble as three independent lanes

Wire Bass → a generator's Reactivity, Mid → a modifier's Amount, and Treble → a combiner's Mix. Each frequency band now controls a different visual parameter independently. The mix changes with the music's spectral balance.

Beat Phase as a wipe control

Connect Beat Phase to a Blend combiner's Mix pin. The mix now sweeps from 0 to 1 within every beat and resets. Change the combiner to Overlay or Screen for a blend that pulses rather than fully switching.

Bloom before Kaleidoscope

Put Bloom before Kaleidoscope, not after. The Kaleidoscope will mirror the bloom glows into every segment, creating a symmetric corona effect. After gives you simple blurred segments — before gives you a crown of light.

Speed as a performance control

Every generator, modifier, and combiner now has a connectable Speed pin. Wire Bass → Speed on a Tunnel Warp and the tunnel rushes forward with every kick. Wire different LFO rates to different generators' Speed pins to make them drift in and out of sync — like two turntables running at slightly different BPMs.

Perspective 3D as a finishing move

Put the Perspective 3D modifier at the end of any chain, right before Output. Wire a very slow LFO (0.1 Hz) to Rotate Y — the entire visual slowly rotates like a floating screen in the void. Add Bloom after it for a glowing halo around the tilted edges. The perspective strength slider in the inspector controls how dramatic the depth effect feels.

Save with descriptive names

Use the bookmark icon to save graphs to your library. Give them names like "Neon Tunnel - Techno Set" or "Soft Ambient - Opener". Your library appears at the top of the presets browser and loads instantly.

Build Your OwnVisualizer.

A Visual Synthesizer.

Chain anything

Combine two sources

Modulate everything

Navigating the Graph.

Pan & Zoom

Adding Nodes

Drawing Connections

Editing Parameters

Texture vs Float pins

Library & Export

Five Node Types.

Generator Nodes

Generative / Algorithmic

Audio-Reactive

Industrial / Glitch Aesthetic

Custom Metal Shaders

Three Ways to Get Started

Required Function Signature

Available Uniforms — GeneratorUniforms

Minimal Working Example

Shader Repos to Adapt

Modifier Nodes

Core Image Modifiers NEW

2.5D Perspective NEW

Combiner Nodes

Input Nodes

Audio / Performance

Time / Control

Building Your First Graph.

Start from a template

Add your generator

Chain a modifier

Add modulation

Built-in Templates.

Power Moves.

Feedback loop from a combined source

Use Difference on the same generator twice

Displace A with A (self-displacement)

Lock reactivity with a Constant node

Bass, Mid, Treble as three independent lanes

Beat Phase as a wipe control

Bloom before Kaleidoscope

Speed as a performance control

Perspective 3D as a finishing move

Save with descriptive names

Start patching.

Build Your Own
Visualizer.

Available Uniforms — `GeneratorUniforms`