Generators

Generators (realtime sources) are generative clips — GPU shaders that draw their picture instead of decoding a file. You drag one onto a timeline, a playlist or a screen exactly like a video, and it behaves like any other clip: it has a duration, opacity and volume curves, mapping, effects and warping.

They are useful where a video file would be wasteful or inflexible — a colour wash behind a logo, a dome fill, a countdown, an audio-reactive backdrop, or a test pattern while a rig is being aligned.

Adding one

Generators live next to your media, in their own tab:

• Media Browser (Produce & Play, the panel under the timeline) → the Generators tab.
• Media Pool in the Show view → the same tab.

Drag a card onto a timeline track, a playlist row, or a screen. The clip is self-describing: its source file is a synthetic token ($[realtime]/<id>), so there is no file on disk to copy, and on a multi-client rig nothing has to be transferred — every engine renders its own copy.

The tab opens on folders — Backgrounds, Abstract & Motion, Nature, Dome & Projection, Interactive, Show & Audio, and Clocks & Data, plus My Generators once you have written your own. Click a folder to see its generators; the bar at the bottom shows where you are, goes back, searches every folder and sets the card size, as it does for your media. Cards show a still "hero frame". Hover one to see it animate.

Catalogue

37 sources, grouped as the browser groups them:

Category	Sources
Background	Solid Color, Gradient, Pattern
Generative	Plasma Field, Warp Tunnel, Petal Vortex, Line Tunnel, Fractal Bloom
Ambient	Aurora, Color Wash, Silk Drift, Cloud Flight
Organic	Liquid Marble, Fire, Open Ocean, Blossom Drift, Flower Field, Camouflage
Geometric	Voronoi Cells, Hex Pulse, Crystal Shatter
Space	Starfield
Dome	Dome Grid, Dome Night Sky, Dome Zenith Waves, Dome Aurora, Dome Hyperspace Tunnel, Dome Aurora Nebula, Dome Fluid Flow, Dome Fire Sphere
Projection	Depth Relief, Depth Parallax
Textured	Texture Kaleidoscope
Interactive	Water, Plasma Globe, Tracked Figure, Koi Pond
Data	Countdown, Digital Clock, Neon Clock
Audio	Spectrum Bars, Oscilloscope
Show FX	Laser Sweep, Strobe, Sonar Pulse

Every source in the catalog is Exaplay's own.

Crystal Shatter fractures the frame into convex shards and drifts them from ice to ember. Fracture sets how many times the pane is cut (a handful of large shards up to a dense crystalline field), Facet tilt how much each shard catches the travelling light, and Heat biases the whole pane towards the Ember colour — bind that one to the audio level and the glass heats with the music.

Open Ocean and Plasma Globe react to the pointer — drag across the preview to steer across the swell, or to pull the arcs towards your finger. The pointer is a parameter of the clip, so what you steer in the preview is what the output shows (see Interaction below). Open Ocean is the most expensive source in the catalog (it resolves a wave surface per pixel), so check the engine's frame rate before putting it on a large output.

The Dome and Projection sources are authored in fisheye/dome space. Depth Relief and Depth Parallax take a depth-map image as a parameter — point them at a PNG or JPEG and they displace the picture from it; without one they fall back to a procedural shape.

Line Tunnel sends thin iridescent lines flowing out of a vanishing point that drifts across the frame. Lines sets how densely they are packed, Warp how far the tunnel's walls wobble away from a circle, and Drift how far the vanishing point wanders.

Fractal Bloom is a Julia-set fractal that never stops changing: its spirals grow tendrils, curl into seahorse shapes and dissolve into glowing dust as the set's constant travels slowly along the edge where it changes the most. Morph sets how far it breathes across that edge, Zoom and Spin frame it, Glow sets how brightly the filaments light up, and the three colours make up the palette. Detail is the iteration count — the picture's sharpness near the filaments and its GPU cost; lower it on a very large output. Audio pulse lets the music push the shape and the glow.

Cloud Flight is the view from an aircraft cruising over a sea of clouds. Daylight picks the light — Dawn, Morning, Noon, Golden hour, Sunset, Blue hour or Moonlit night (with stars and the moon) — and Sun direction turns the sun (or moon) around the aircraft. Choose By time of day and the Time of day slider (0–24 h) moves smoothly through the whole day instead: night, blue hour, dawn, morning, noon, afternoon, golden hour, sunset and back to night, the stars fading in and out and the sun drifting with the hour. Animate it or bind it to a variable, and the sun rises during the show. View looks forward out of the cockpit, sideways out of a window, or through a framed cabin window. Cloud type picks the shape of the clouds: Cumulus (separate fair-weather heaps, the default), Sea of clouds (a broad, flat-topped, almost closed deck), Towering cumulus (tall, separate towers you can fly between at a middle altitude), Stratus / fog sea (one smooth, softly rolling blanket), Altocumulus (many small puffs in a thin layer), Cloud streets (rows of heaps along the flight) or High cruise (the view from cruising altitude: a vast deck of small cauliflower cells running to the horizon, under a deeper blue sky with a pale band of haze on the horizon — set Sun direction behind you for bright tops over blue valleys). The shadows in every type take the colour of the sky above them — the cool blue of the valleys between the heaps by day, violet at dusk. All the other settings work on top of whichever type is chosen. Airspeed sets how fast the deck streams past, Altitude how high above it you fly (all the way down, you fly through the clouds), Coverage how closed the deck is overall, Density how thick each cloud is — low for thin veils you can see the land through, high for solid, heavy heaps (it also sets how dark their shadows are) — and Puffiness, Haze and Bank shape the rest. Even with Haze at 0 the far distance still fades softly into the horizon, as it does on the clearest day. Light rays fan out from the gaps between clouds in front of the sun, with the clouds' shadows as dark spokes between them — most striking with a low sun. City lights come on as it gets dark: towns glow up through the holes as points of light, taken from the built-up areas of the Ground image (or scattered towns without one), and warm the clouds' undersides. Lightning sets how often a flash lights a cloud from inside (0 = never); strikes follow the clip time, so every machine of a fleet flashes together. Flash fires one by hand or through a binding — to a variable, or to the audio level for thunder on the beat. Holes punches clear openings through an otherwise closed deck — none at 0, about half the sky at 1 — and Hole size makes them smaller or wider; the land shows through them, with the clouds' shadows on it. The land below is the Ground image: it ships with a Landsat 9 picture of farmland in southern Poland (NASA Earth Observatory / USGS, public domain), and you can point it at any picture of your own — an aerial photo or a satellite still works best; for the preview, use one whose sides are powers of two (1024 × 1024, 2048 × 2048). It is tiled with mirrored repeats so it has no seams, Ground scale sets how large one tile is, and it takes the light and haze of the chosen daylight. Clear the field and a procedural patchwork of fields and water is drawn instead. Like Open Ocean it is one of the more expensive sources — each pixel marches through the cloud volume — so check the engine's frame rate on a large output, and lower Quality if it drops.

Tracked Figure is an abstract but anatomically shaped human — adult proportions, shoulders, rib cage, waist and hips, muscled arms and legs, hands and feet — that stands wherever a tracking value puts it — the typical "a person walks past and their figure follows" effect. Position X moves it across the frame; Position Y (depth) moves it back on the floor, where it stands higher and (with Depth scaling) smaller. Motion blends from standing to walking, Arms raises both arms, Lean tilts the upper body, and Audio bounce lets it dip to the music. Style chooses how the body is drawn: Particles (the default — glowing dust, dense in the body and rising off it), Line field (horizontal lines across the whole frame that the body bends and lights up as it walks through them), Contours (rings flowing outwards from the body like an aura), or the plain Neon outline, Silhouette and Joints (dots and bones, the look of a skeleton tracker), or Fibres (the body spun from fine strands that run along the limbs, with long ribbons of strands streaming off behind it — rising, fanning out and waving as the figure moves, while the back of the figure dissolves into it; Spread sets how far the trail reaches), or Light threads (a figure spun from long threads in the colours of the spectrum that hang from its arms and shoulders and flare out down to the floor like wings — raise the arms with Arms for the full effect; Spread sets how far they flare, Density how many threads there are). Density sets how many particles or lines there are, Spread how far they reach beyond the body, and Accent is the second colour they blend into. To drive it from a tracker, bind Position X (and Y) to a variable such as person_x, then map the tracking channel to that variable in the Inputs dialog (Of the clip → ⚡ Variable) — or map the channel straight to ★ Position X. Arms, Motion and Lean are bindable too, so a second channel (a hand's height, a speed) can pose the figure. It has a Transparent background switch.

Direction and view. With Turn with movement on (the default), the figure turns to face the way it walks: when Position X moves left it turns left, when it moves right it turns right, and when the person stops it keeps facing the way it last went. The turn takes a fraction of a second, passing through a moment where the figure faces the audience. Small jitter from a tracker does not make it turn, and a sudden jump (a cue moving it to a new spot) does not count as walking. Face left sets the direction it faces before it has moved, or always when Turn with movement is off. View chooses how the figure is seen: Three-quarter (the default), Side (a profile), Front (facing the audience) or Back. In the Neon outline, Contours, Particles and Fibres styles, faint anatomy lines tell the two apart: collarbones and chest from the front, spine and shoulder blades from the back. Direction only changes the Three-quarter and Side views; Front and Back always face the same way. View and direction apply to the animated figure, not to a tracked skeleton, which takes its pose from the tracker.

A tracked skeleton. Switch on Use skeleton (joints) and the figure takes its pose from a skeleton tracker (a depth camera such as a Kinect, or a pose estimator) instead of animating itself: head, neck, shoulders, elbows, hands, pelvis, knees and feet. Each joint is a pair of values, a position in the frame from 0 to 1 (left→right, bottom→top, like Position X / Y), written to realtime.params.u_j_<joint>_x / _y — for example u_j_l_hand_y. The joints are inputs, not controls, so they do not appear in the inspector; the Inputs dialog lists them as Skeleton · Left hand Y and so on, and any OSC or REST client can write them on the clip:

POST /data
{ "type": "exaObj", "uid": 12345678,
  "values": { "realtime.params.u_j_head_x": 0.52, "realtime.params.u_j_head_y": 0.81 } }

The figure's size comes from the tracked torso, so Position, Height and the pose sliders do not apply while a skeleton is tracked. A joint that is not tracked is left at −1 and its limbs are simply not drawn. Without a head, neck and pelvis there is no body to draw, and the figure falls back to its own animated pose at Position X / Y — the output never goes empty when the tracker loses the person.

Koi Pond is a pond seen from above, made for a floor projection: koi of the classic varieties (kohaku, ogon, platinum, sanke, showa) — with a real koi's outline, scales, large translucent pectoral fins, a rippling dorsal fin and barbels, swimming in an S with their own shadows on the bed — swim at different depths over a bed of rounded pebbles, seen through a moving water surface that bends everything beneath it and throws glints and caustics; clumps of lily pads with water lilies and a few petals float on top. The koi are simulated, not animated: each fish remembers how it was swimming, so it meanders at its own pace, turns in arcs and never reverses on the spot, keeps a little apart from the others and mills about with them loosely. When someone walks through, the koi near them take fright — they turn away and dart off, and calm down again over the next seconds — and rings of ripples spread from the visitor's feet. A click or a tracker that jumps does not make the koi jump: they react to the visitor's position smoothly, as if the person walked there. The visitor is the clip's pointer, so in the preview you simply move over it; on the floor, map the tracked person's position to Pointer X / Y in the Inputs dialog (Of the clip). Set Visitors to Pointer + person 2 and bind Person 2 X / Y for a second tracked person. Flee distance is how close a visitor gets before the koi react, Shyness how hard they react (0 = they ignore people), and a click or trigger drops a ripple. Water surface sets how strongly the surface refracts and reflects, Pebble size the stones, Lily pads and Petals what floats on top, and Water / Tint the colour of the water column. Light direction and Light height set where the light comes from (in degrees; both can be bound, for a sun that moves through the day), Light and Light colour its strength and colour — every shadow, highlight and glint follows it, and a low light throws long shadows. Bed relief gives the bed depth under that light: its stones are shaped from the bed picture's own brightness, or from a Bump map (a height image, light = high) if you set one; a low light rakes across them. The bed is a photo of river pebbles out of the box — Poly Haven's Ganges River Pebbles, a CC0 (public-domain) texture that ships with Exaplay in the program folder under html\images\generator-assets\koi-pond\ together with its licence note. Bed image replaces it with a picture of your own — a photo of the real gravel, sand or tiles under the projection, for example — seen through the same water (and tinted less, so it stays recognisable); clear the field and the pond draws its own procedural pebbles instead. Bed tiling repeats a seamless texture that many times per frame height, square, so its stones keep their shape at any aspect (the default, 1.6, suits the shipped pebbles); set it to 0 to stretch a site photo over the whole frame.

Shark Lagoon is a tropical lagoon seen from above, also made for a floor projection: blacktip reef sharks — sandy tan, with the short, broadly rounded snout of the species, long swept-back pectoral fins, the tail seen on edge, eyes with a slit pupil and a wet glint, and the black fin tips they are named for — cruise over pale coral sand rippled by the current, meadows of seagrass and scattered coral heads (brain coral, boulder coral, staghorn, rock crusted with pink coralline), their shadows sharp on the sand below them. A school of baitfish flickers silver through the shallows and a stingray glides along the bottom. The water is drawn the way real water behaves: the deeper it is, the more of each colour it swallows — red first — so the shallows are pale turquoise over white sand and the channel that winds through turns deep blue; sunlight focused by the moving surface throws a web of caustics onto the sand and over the sharks' backs.

Like the koi, every animal here is simulated: the sharks cruise in wide, unhurried arcs; the baitfish are a real school — they keep together and swim the same way, burst apart when a shark comes close and close up again behind it; the rays glide along the bottom.

Whoever walks through is the visitor, exactly as in the Koi Pond (map the tracked person to Pointer X / Y; Visitors and Person 2 X / Y for a second person). The school scatters from a visitor and parts around every shark, the rays glide out of the way, and most sharks keep their distance — but Curious sharks (1 by default, up to 2) circle the visitor instead, slowly, now nearer, now further, and follow them when they walk on. Nothing swims backwards and nothing jumps, even when the visitor jumps (a click, or a tracker picking someone up again): every animal follows the visitor's position smoothly. Sharks, Shark size, Fish school and Stingrays set the cast, Flee distance and Shyness how close a visitor gets and how hard the animals react, Depth how deep the lagoon is, Reef how much of the shallows is reef, Water the colour the water gives the sand in the shallows and Deep water the colour of the deep. Sand image replaces the procedural sand with a picture of your own (Sand tiling as the Koi Pond's Bed tiling), and Light direction, Light height, Light and Light colour work as in the Koi Pond — a low sun throws long shark shadows across the sand. Sand relief shapes the sand's ripples and the coral heads under that light; with a Sand image the relief comes from the picture's own brightness, or from a Bump map (a height image, light = high) if you set one.

About the simulated generators. The Koi Pond and the Shark Lagoon keep the state of every animal from one frame to the next, and advance it in fixed steps of the clip's time — so the behaviour is the same at any frame rate, pausing the clip freezes the animals, and restarting or seeking the clip starts the scene afresh (already settled, not bunched up).

Across several machines (multi-client), the master is in charge of the animals: it sends where every animal is and how it is moving to its clients about 30 times a second, and each client steers its own animals smoothly towards that — so a floor spread across several machines shows the same animals, and a fish swims across the seam from one machine's part into the next. Between the updates, and if the master goes away, each client simply keeps the animals swimming on its own. What stays each machine's own is the small detail (the exact beat of a tail), which no one can see across a seam. This needs nothing set up: it rides the same connection as the playback sync, to the same clients. To switch it off (for example for third-party OSC gear that does not accept binary data), set sync.sim-state to false in the communication settings.

Transparent background

The sources that draw something over a background — Countdown, Digital Clock, Neon Clock, Spectrum Bars, Oscilloscope, Laser Sweep, Strobe, Sonar Pulse and Tracked Figure — have a Transparent background switch. Switch it on and the background (and the Neon Clock's brick wall) is dropped: only the digits, bars or beams are drawn, with their glow fading into the layer beneath. Put the clip on a layer above your picture to lay a clock or a countdown over it. The preview shows a checkerboard wherever the output will be see-through.

For the Tracked Figure over your own background, also set Floor to 0: the floor glow and grid are part of the picture and stay visible when the background is dropped. Every style keys cleanly — the figure, its trail, the Light threads' cape and the particles fade into the layer beneath.

The Countdown and the Digital Clock fit their whole readout into the clip's frame at Size 1, whatever the frame's shape; a larger size makes the digits bigger than the frame.

Parameters

Select the clip: its parameters are the first panel in the Inspector. Each source has its own controls — speed, scale, colours, and so on — with a live preview above them.

Interaction

Interactive sources (Water, Plasma Globe, Open Ocean, Depth Relief, Depth Parallax, Sonar Pulse) also show Pointer X, Pointer Y and a Click → Trigger button. They set the pointer the output sees:

• drag on the preview to move the pointer; pressing on it clicks, releasing lets go;
• set Pointer X / Y with the sliders for an exact position;
• Trigger clicks once at the pointer — a ripple on Water, a ring on Sonar Pulse.

The same values can be driven live from the Inputs dialog (Of the clip → Pointer X, Pointer Y, Click / trigger) or by writing realtime.pointer.x, realtime.pointer.y (0–1) and realtime.click (0/1) on the clip through the REST API.

Parameters are ordinary clip values under realtime.params.<key>, where <key> is the shader uniform's name (they all start with u_). So a plasma clip's speed is realtime.params.u_speed, and it can be set from anywhere a clip value can be set:

comp_main.media3.set:realtime.params.u_speed=2.5

See the TCP Command API and the HTTP REST API.

The three ways to drive one from inside a show, all writing that same value:

From	How
A timeline curve	A Data Track with the Exaplay value output and the parameter as its Target — the ⚡ wizard lists the parameters of the source that clip runs and fills in each one's range
Inputs	An input channel (touch, sensor, controller, tracking) mapped to the parameter — or, better for anything several things should feed, to a variable the parameter is bound to (below)
Show control	The set: line above, over TCP, UDP, OSC or from a cue script

Decimals arrive intact on every one of those routes, whatever the parameter's current value is — a 0–1 parameter really does sweep, not jump between 0 and 1.

Bindings — driving a parameter from a signal

Any slider marked as bindable can follow a signal instead of holding a fixed value. Open the parameter's binding row in the Inspector and pick a source:

Source	What it follows
Audio · Level	Overall level of the engine's master mix
Audio · Band 1–8	One of eight frequency bands of that mix
Pointer · X / Y / Pressed	The pointer, for interactive installations
Variable (OSC / external)	A named variable you drive yourself (below)

A binding stores a min and max; each frame the parameter becomes mix(min, max, signal). The Inspector preview mirrors the same maths, so what you see there is what the output does.

The audio signals are auto-gained: each metric is normalised against its own recent peak, so the response feels the same at any programme loudness, master volume or audio buffer size. Absolute levels in the browser preview are simulated — only the dynamics match the engine.

Removing a binding

Set the binding source back to — static —. Value writes are merges, so clearing a binding by deleting the key client-side does not remove it — the UI writes an explicit "none" for you.

External variables

A Variable binding reads realtime.vars.<name> on the clip, a 0–1 value that nothing inside Exaplay writes. That is the show-control hook: an OSC bridge, a script, or any REST client can drive it.

POST /data
{ "type": "exaObj", "uid": 12345678, "values": { "realtime.vars.energy": 0.8 } }

Each binding then applies its own min→max, so one variable can drive several parameters at different ranges.

The Inputs dialog offers a generator clip's bound variables as targets (Of the clip → ⚡ Variable), so a tracked position or trigger can feed a shader directly.

Interaction

Water responds to clicks — ripples spread from the pointer. Interactive sources receive pointer and click state as realtime.pointer.* and realtime.click, which, like everything else here, can also be written from outside.

Your own generators

Besides the built-in catalogue you can write generators of your own — by hand, or by having an AI assistant (ChatGPT, Claude, …) write them for you.

1. In the media browser's Generators tab, click New generator….
2. With an AI: type a one-line brief under Describe the effect ("glowing jellyfish that pulse with the bass"), click Copy AI guide and paste it into your AI chat. The guide tells the assistant exactly what Exaplay needs — the shader dialect, what is already declared, the rules for a show-safe shader and the answer format. Copy its whole answer, then click Paste AI answer: the name, parameters and shader are filled in. (The guide itself ships with Exaplay at /generators/GENERATOR-GUIDE.md; Open guide shows it.)
3. By hand: edit the Shader (a GLSL ES 1.00 fragment body: declare your parameter uniforms, write gl_FragColor in void main()) and the Parameters list (JSON — slider, color, toggle, select or texture).
4. The preview runs your shader live, and it is compiled twice — for the browser preview and for the engine's output. Every error is shown with the line number in your shader, and a generator that does not compile for both cannot be saved. A classic trap it catches: code copied from Shadertoy is a newer dialect (an integer max(), %, switch …) that compiles for the engine but not for the preview.
5. Save generator. It appears under Generators → My Generators and is used like any other: drag it onto a timeline, tune and bind its parameters in the inspector, drive them from tracking or show control.

Saved generators are kept on this machine in Documents\Exaplay3\generators\ (one .json each). A clip carries its generator with it: the shader is stored in the clip itself, so the show plays it on every multiclient client and after the project is copied to another machine — nothing needs to be installed there. Editing or deleting a generator in the library does not change clips already in a show; add the edited generator again to use the new version.

A shader runs on the output's graphics card

A generator is code. Test a new one in the preview and on a rehearsal output before a show: a very heavy shader lowers the output's frame rate, and one that the engine refuses to compile shows nothing (the reason is in the engine log).

What realtime sources are not

• They are not the post-processing effects. An effect processes whatever a clip already shows; a realtime source is the clip. Both can be used on the same clip — see Visual Effects.
• They are not 3D scenes. Earlier builds briefly carried three.js "scene" sources; those are gone. Every source in the catalogue is a native GLSL shader that renders identically in the browser preview and on the output.
• They are not files. Nothing is copied to render clients, and a realtime clip can never be reported as missing media.

Related

• Visual Effects · Effects Reference
• Data Tracks — animating a parameter along the timeline
• Show Control — driving realtime.vars.* from outside