Effects

Every effect, one block each: its preview, what it does, and what each control means: together. An effect writes per-pixel color into its Layer's buffer each tick; modifiers reshape the result and a driver sends it out. Effects that name an index color read the global palette (the palette control on Drivers) via colorFromPalette. Each block's emoji are its tags() (origin/creator/audio: see the tag emoji legend); Dim is its native axes (Layer extrudes a lower-dim effect onto a bigger grid). Effects are grouped into sections by origin, and each block carries that effect's preview, behavior, and control descriptions together. How the layout here maps to the source and asset folders is the folder-structure decision.

Effects are built from the shared power functions: the drawing, field and motion routines every effect composes; that page lists each one with its callers.

Jump to: MoonLight · MoonModules · WLED · FastLED · MoonLight-native

Some WLED-origin effects show a preview gif from WLED-Utils by scottrbailey (the canonical WLED effect gif set, cross-linked with credit); these show WLED's rendering. Effects with a local ../../assets/… gif show our own output.

MoonLight effects

Module	Details
ColorTrails 💫🖌️💨🌫️ · 3D Emitters pouring color into a flow that carries and folds it. There is no velocity field: one noise value shifts each row sideways, one shifts each column, and the two shears compose into a swirling current. A large grid is steered by a few hundred numbers, which is why it runs where a solver does not. Compare with Fluid: the solver when the medium is the subject, this when the color is.	speed — how fast the emitters travel.flow — how far a row or column is pushed: the shear amount.flowSpeed — how fast the flow itself drifts and reverses.scale — the profiles' spatial frequency: a few broad bands or many fine ones.persistence — how long color survives, as a half-life.colorSpeed — how fast the emitters walk the palette.size — the orbit's radius and the Lissajous figure's reach.mode — all three emitters, or one at a time to see what each contributes.flowType — the field carrying them: Noise, Radial out, Radial in. Tests: none yet API: reference Details: none yet
DistortionWaves 💫 · 2D Two interfering sine waves beat against each other into a moiré color field.	freq_x / freq_y — horizontal/vertical wave frequency (1–8).speed — animation rate (0 = frozen). Tests: DistortionWaves API: reference Details: none yet
FixedRectangle 💫 · 3D A solid color filling a positioned box within the grid, with an optional alternating-white checker on the box's pixels.	red / green / blue / white — the box color.X position / Y position / Z position — the box's origin corner.Rectangle width / height / depth — the box extent on each axis.alternateWhite — alternate box pixels to white in a checker pattern. Tests: FixedRectangle API: reference Details: none yet
FreqSaws 💫🎶 · 2D Audio-reactive sawtooth waves: each column maps to a frequency band whose magnitude drives a per-band oscillator speed, so louder bands sweep their sawtooth up the column faster, with three phase methods.	fade — background decay per frame.increaser — how fast a band's speed ramps up with its magnitude.decreaser — how fast a silent band's speed decays.bpmMax — ceiling on a band's oscillation speed.invert — flip alternate columns vertically.keepOn — keep oscillating even when a band is silent.method — phase model (Chaos, Chaos fix, BandPhases). Tests: FreqSaws API: reference Details: none yet
LavaLamp 💫🦅 · 2D Three slow blobs through a black→red→orange→yellow→white ramp: atmospheric lava look.	bpm — blob drift speed.radius — blob influence radius.intensity — field gain into the black→red→orange→yellow→white ramp. Tests: LavaLamp API: reference Details: none yet
Lines 💫 · 3D Sweeps axis-aligned planes in sync; red/green/blue name the X/Y/Z axis: a preview-orientation test pattern.	mode — lines sweeps a plane, panel dots walks a dot per panel.speed — sweep BPM, in lines.axis — which plane sweeps: all, x, y or z, in lines.panelW / panelH — the panel the dot walks, in panel dots. Tests: none yet API: reference Details: none yet
Metaballs 💫🦅 · 2D count blobs orbit via integer sin/cos; metaball field per pixel: bright HSV merge/split.	bpm — orbit speed.radius — blob influence radius.count — number of orbiting balls (1–8).hue_shift — rotate the palette index. Tests: Metaballs API: reference Details: none yet
Particles 💫🦅✨ · 2D A swarm of drifting particles with persistent fading trails.	count — number of particles (1–255).speed — drift velocity.fade — trail persistence (higher = longer tails).hue_shift — rotate every particle's hue. Tests: Particles API: reference Details: none yet
Plasma 💫🦅 · 3D Summed sine waves on orthogonal + diagonal axes; large rolling blobs (3D on volumetric layouts).	bpm — roll speed.scale_x / scale_y — blob size on each axis; larger is bigger and calmer.hue_shift — rotate the palette index. Tests: Plasma API: reference Details: none yet
Praxis 💫 · 2D An algorithmic palette pattern driven by two beat oscillators (a macro and a micro mutator) whose frequencies and ranges reshape the hue field over time.	speed — how fast the pattern advances.macroMutatorFreq / Min / Max — the coarse mutator's beat rate and range.microMutatorFreq / Min / Max — the fine mutator's beat rate and range. Tests: Praxis API: reference Details: none yet
Rainbow 💫 · 2D Diagonal animated rainbow: always-visible default/test effect.	speed — animation BPM (one full hue cycle per beat). Tests: Rainbow API: reference Details: none yet
Random 💫✨ · 3D Lights one random light per frame in a random palette color over a fading background: a sparse, palette-tinted sparkle.	fade — how fast prior sparkles fade to black. Tests: Random API: reference Details: none yet
Rings 💫🦅🖌️🎡 · 2D Expanding concentric rings from random centers, additive overlap (calm defaults).	count — number of concentric rings (1–255).speed — expansion rate.thickness — ring band width.hue_shift — rotate every ring's hue. Tests: Rings API: reference Details: none yet
Ripples 💫🦅 · 3D Distance-from-center sets a per-column wave phase; the lit surface ripples like water.	speed — wave animation rate (0 = frozen, 99 = fast).interval — wavefront spacing (low = tight rings, high = wide). Tests: Ripples API: reference Details: none yet
RubiksCube 💫 · 3D A 3D Rubik's Cube projected onto the volume: it scrambles, then plays its solution back one turn at a time, the six faces in their standard colors.	turnsPerSecond — how fast the cube turns.cubeSize — the cube order (1×1 up to 8×8).randomTurning — turn endlessly at random instead of scramble-then-solve.usePalette — color the faces from the palette, not the classic colors. Tests: RubiksCube API: reference Details: none yet
Fireworks 💫✨ · 2D Shells rise, stall, and burst into sparks that arc over and fall. Nothing schedules the apex: the shell decelerates under gravity and bursts when its vertical velocity crosses zero, so a faster launch bursts higher without a second control. Physics runs on elapsed time, so the same settings behave identically at any frame rate.	launchRate — how often a new shell goes up.launchSpeed — how hard it is thrown, and so how high it bursts.gravity — how fast everything falls, per 60 Hz of simulated time.sparks — sparks per burst.sparkLife — how long a spark survives.drag — air resistance flattening the arc.fade — trail length (the Layer's decay, not the pool's). Tests: none yet API: reference Details: none yet
Fish Tank 💫🎶✨👾 · 2D An aquarium on a light wall: fish of three shapes swim across a dark tank, each in its own color from the active palette, tails beating. The art carries shade roles rather than fixed colors, and each fish fills them from its own place on the palette, so one drawing yields as many colorways as there are fish. Uses the global palette, each fish's band a paler version of its own body color.	fish — how many broad tropical fish (0-8).slim — how many slender fish (0-8).school — how many tiny schooling fish (0-8).speed — swim rate in body-lengths, the same on any grid.spriteSize — integer magnification; 0 is auto, scaling with the grid.audioReactive — each sprite follows its own band, so the scene breathes. Tests: none yet API: reference Details: none yet
Flying Toasters 💫🎶✨👾 · 2D The classic screensaver on a light wall: chrome toasters with flapping wings and slices of toast drift diagonally across the dark, forever. The wing flap carries a per-toaster offset, so the flock never falls into sync. The sprites carry their own colors (chrome, wing, crust), so the global palette does not apply. Needs a grid at least the toaster's size (12×9).	toasters — how many fly (1–12).toast — how many slices trail along (0–8).speed — drift rate in sprite-widths, the same on any grid.spriteSize — integer magnification for toasters and toast; 0 is auto.audioReactive — each sprite follows its own band, so the scene breathes. Tests: none yet API: reference Details: none yet
FixedPoint 💫🖌️ · 2D Shapes placed between pixels rather than on them. A clock hand drawn on whole pixels jumps a pixel at a time and reads as broken; the same hand at a fractional position moves smoothly, because a pixel's brightness carries the fraction its position cannot. Eleven figures, from a geared clock through a spirograph to boids and a swaying tree.	demo — which figure, or all to cycle them.bpm — how fast the orbits and curves run; the clock keeps its own.fade — how much of the previous frame survives, which leaves the trail.dwell — seconds each demo holds before all moves on.drift — how far the scene wanders from center, in pixels; 0 pins it.zoom — the camera pushes in and settles back; 0 holds it fixed. Tests: FixedPoint API: reference Details: none yet
MovingHead 💫🎶🎯 · 1D Aims a rig of moving heads as one instrument. Pan and tilt sweep at different rates, so a beam traces a path rather than a line, and formation decides how the heads relate. The first effect that aims a fixture rather than only coloring it. fan, mirror, chase, cross and unison. A fixture chain is one-dimensional, so lay the rig out as a 1 x N grid.	formation — how the heads relate:panBpm / tiltBpm — sweep rates. Differing rates trace a path, not a line.panRange / tiltRange — how much of the fixture's travel to use.panCenter / tiltCenter — where the sweep is centered; 128 is the middle.audioReactive — the beam widens with the room, each head on its own band.gobo / rotate — the beam's wheels, as raw bytes; see the manual.goboOnBeat — roll a new gobo on a bass hit, then hold it a moment. Tests: none yet API: reference Details: none yet
Pacman 💫🎶✨👾 · 2D The arcade cast crossing a light wall: Pacman chomps his way along while the four ghosts drift past, each in its own color, wrapping around the edges forever. The characters travel independently, each on its own path. Pacman keeps his yellow; the ghosts take their colors from the active palette.	pacmen — how many Pacmen (0-4).ghosts — how many ghosts (0-8); the arcade cast is four.speed — travel rate in sprite-widths, the same on any grid.spriteSize — integer magnification; 0 is auto, scaling with the grid.audioReactive — each sprite follows its own band, so the scene breathes. Tests: none yet API: reference Details: none yet
Space Invaders 💫🎵👾 · 2D The 1978 formation marching down the wall: five ranks stepping sideways in the two-frame wiggle, dropping a row and reversing at each wall, and speeding up as the ranks thin. That acceleration is the defining mechanic. Invaders fire down, the cannon fires back, and a landing resets the board. The invaders take their body color from the active palette.	marchBpm — steps per minute when full; it speeds up as the ranks thin.stepX — how far a step moves the formation sideways, in pixels.dropY — how far a wall turn drops it, in pixels.size — magnification per art pixel; 1 on a matrix, 2 or more on a wall.audioReactive — the formation steps on transients, locking to the track. Tests: none yet API: reference Details: none yet
Sprite Fountain 💫🎶✨👾 · 2D A fountain that throws the project's whole sprite cast: fish, Pacman and his ghosts, toasters and toast, and the three invaders, launched from the floor on a sweeping nozzle and falling back under gravity. The art is shared with the effects that introduced it, so a fix to a fish fixes it in both places. Colors come from the active palette, one per sprite, held for its whole flight.	lift — how hard the nozzle throws; it scales with the grid.pull — gravity. 3 gives a two-second arc, long enough to read a toaster.rate — sprites launched per beat of the emit clock.emitBpm — launches per minute, so the plume's density is a choice.size — integer magnification per art pixel.audioReactive — one sprite per band, so the cast maps onto the spectrum. Tests: none yet API: reference Details: none yet
Pong 💫🎵👾 · 2D Two paddles rallying a ball, the attract mode of the 1972 original where both players are the machine. A perfect tracker would rally forever and never look like a game, so each paddle has a reaction delay and a small aiming error, re-rolled every exchange. That is what produces the occasional point. Uses the global palette.	rallyBpm — ball crossings per minute, the same time on any grid.paddle — length as a percentage of the court; short paddles miss more.reflex — how sharply a paddle chases. Below full it lags a fast ball.size — integer magnification, when the ball is a sprite.spriteBall — swap the square for a sprite, re-picked on every hit.audioReactive — the ball advances only on the beat, in time with the track. Tests: none yet API: reference Details: none yet
Aurora 💫🖌️🌫️🎡 · 3D Several noise fields, each on its own clock, read in polar coordinates and composited into curtains of light. Nothing is simulated: layers of one field at different scales interfere, and that is what reads as curtains folding through one another. The strongest layer at each pixel wins, so they stay distinct rather than averaging into haze.	speed — master rate; every layer scales from it, and 0 freezes it.scale — noise cells across the grid; low is broad, high is fine.layers — how many fields are composited, and the main cost knob.warp — how far the field displaces its own angle, folding a curtain over.twist — how much the radius shears the angle, giving the curtains their lean.segments — kaleidoscope wedges; 1 leaves the composition unfolded.contrast — how much of the field lights; low is cloud, high is sharp.octaves — detail within each layer, multiplying the cost knob.polarTable, polarTable16 — as PolarNoise above. Tests: none yet API: reference Details: none yet
Ballpit 💫✨ · 2D Falling balls that pile up and shove each other aside. The heap is emergent: gravity pulls, the floor stops, and contact between neighbors makes the shape. tilt turns the pit into a slope and the pile slides and re-settles. Collisions are the one non-linear part of the particle kernel, so the pool is small.	balls — how many share the pit.gravity — how hard they fall.size — contact radius in pixels: how far apart balls sit when touching.bounce — restitution: how much speed a contact keeps.tilt — sideways force, turning the pit into a slope.drag — damping, so the heap settles instead of sloshing. Tests: none yet API: reference Details: none yet
Dissolve 💫 · 2D Two color fields trade places pixel by pixel in an order that looks random but is computed, so the transition needs no per-pixel state and no shuffled index list. Two devices rendering the same frame dissolve identically without exchanging anything.	bpm — how fast one transition completes.spread — how long pixels spend mid-flight; 0 gives a hard edge.eased — ease the progress instead of sweeping linearly.scatter — random order; off gives a positional wipe from the same code. Tests: none yet API: reference Details: none yet
Echo 💫✨ · 2D The previous frame fed back through a zoom and rotation, dimmed, with a bright source drawn on top: trails that spiral away from themselves, like a camera pointed at its own monitor. Shows that feedback is not a primitive: once the grid can be read as a texture (sampleWrap), the whole family of trails, zoom blur and smear is a few lines.	bpm — how fast the source orbits.zoom — how much the feedback grows each frame.rotate — rotation per frame, which turns the trail into a spiral.decay — how fast the echo fades; higher is a shorter trail.size — radius of the bright source. Tests: none yet API: reference Details: none yet
Spectrum 💫🎶 · 2D An audio analyser with real meter ballistics: bars rise fast enough to catch a transient and fall slowly enough to read, and a peak dot marks the recent maximum and drifts down. The asymmetry is the whole point; a symmetric follower either misses the hit or flickers.	attack — how fast a bar rises toward a new level.release — how fast it falls back.peakDecay — how fast the peak dot drifts down.showPeaks — draw the floating peak dots.colorByColumn — color per band instead of by height. Tests: none yet API: reference Details: none yet
Truchet 💫🖌️ · 2D A maze of interlocking arcs that never repeats, drawn without storing a single tile. Randomly turned tiles join into continuous winding paths across the surface: the pattern looks designed, and nothing designed it. The representative 2D shader: no 3D, no rays, no float, and cheap on any target.	bpm — how fast the pattern drifts.scale — tiles across the short side.thickness — how fat the arcs are.softness — edge softness: the anti-aliasing width.shuffle — reshuffles which way the tiles face.drift — slide the pattern instead of holding still. Tests: none yet API: reference Details: none yet
Fluid 💫🖌️🌊💨 · 3D Light poured into a simulated medium and carried by it. Every other flow here is a function of position and time; this one is state, so a jet fired now changes where everything downstream goes for seconds afterwards. On a cube every depth slice is its own medium, so the slices differ. Sized for the desktop and the P4.	jets — how many places light is poured in.force — how hard each one pushes the medium.swirl — how fast the jets sweep, which is what stirs vortices.viscosity — how much the medium drags on itself; high is syrup, low smoke.persistence — how long dye survives, as a half-life.iterations — pressure-solve effort, and the cost knob. Tests: none yet API: reference Details: none yet
Nebula 💫🖌️💨🌫️ · 3D A noise field decides where light is born, a curl flow decides where it goes, and between them the cloud keeps folding into itself. The emitter is a field rather than a handful of dots, so light enters everywhere at once and the flow shapes a whole cloud instead of drawing trails. Held at 16 bits and dithered on the way out, which keeps a slow fade smooth.	speed — how fast the medium moves, and with it the whole cloud.scale — the field's cell size; low is broad clouds, high is wisps.contrast — what fraction of the field is bright enough to be born.persistence — how long light survives once it is in the flow, as a half-life.octaves — detail within the field, and its cost knob.fieldScale — compute the field at half or quarter resolution and stretch it.fieldRate — recompute the field every N frames; the flow still runs each one. Tests: none yet API: reference Details: none yet
Trails 💫🖌️💨🌫️ · 3D Dots thrown into a moving medium, leaving tails the flow carries and bends. Nothing draws a tail: it is the previous frames' dots, transported along a velocity field and dimmed, which is why the flow's shape is visible in it. On a cube each depth slice gets its own flow. The trail plane is 16-bit, which is what lets a tail fade smoothly rather than stepping.	speed — how fast the medium moves, and with it every tail.dots — how many emitters are throwing light in.scale — the flow field's cell size; low is broad sweeps, high is eddies.persistence — how long a tail survives, as a half-life.breathe — how much the flow's strength rises and falls. Tests: none yet API: reference Details: none yet
Tunnel 💫🖌️🌫️🎡 · 3D A texture mapped onto the inside of an infinite tube, so the viewer appears to fly down it forever. Nothing is 3D: the angle around the center is one texture coordinate and the reciprocal of the distance is the other, which is perspective for the price of a divide.	bpm — how fast the tunnel flies past.depth — texture scale along the tunnel; higher is finer rings.twist — rotation per unit depth, so the tunnel corkscrews.segments — kaleidoscope the wall; 1 leaves it plain.octaves — wall texture detail, and the cost knob.vignette — darken toward the vanishing point so it reads as receding. Tests: none yet API: reference Details: none yet
VectorBalls 💫🖌️ · 2D A rotating 3D object drawn as shaded spheres, the demoscene classic that named the technique. The smallest complete demonstration of putting 3D on a panel: rotate, project, sort back to front, shade by distance, draw. Without painter's ordering a far ball paints over a near one and the object turns inside out.	bpm — rotation speed.size — ball radius at the object's center, in pixels.spread — how far apart the balls sit.distance — how far the object is from the viewer.fade — dim the far balls, which is what reads as depth. Tests: none yet API: reference Details: none yet
WaterRipple 💫🧬 · 2D A propagating wave simulation: drops land, their rings spread outward, reflect off the edges and interfere where they cross. The crossing is what a drawn ripple cannot fake, because two rings meeting have to add and cancel. Distinct from Ripples, which draws clean concentric circles; this behaves like water.	speed — simulation steps per second: how fast the water itself moves.dropRate — how often drops land, in time rather than per frame.damping — how fast waves lose energy; higher is calmer water.strength — how hard a drop hits.colorByHeight — color by height, so crests and troughs read differently.hueBase / hueSpread — where the still surface sits, and how far waves go. Tests: none yet API: reference Details: none yet
Raymarch 💫🖌️ · 2D A lit 3D scene rendered by marching a ray through a distance field, one ray per pixel. Nothing draws a sphere: the scene is a function returning the distance to the nearest surface, and the spheres emerge where each ray stops. Compiled only where the chip has a hardware FPU. Cost is per pixel, so steps trades quality against it.	bpm — how fast the scene animates.steps — ray marching steps: the quality and cost knob.blend — how much the two spheres melt into each other.cameraY — camera height above the floor.showFloor — include the ground plane. Tests: none yet API: reference Details: none yet
PolarNoise 💫🖌️🌫️🎡 · 3D A warped noise field addressed by angle and radius, folded into a kaleidoscope. The field turns and breathes around the center rather than scrolling past it. Cost scales with octaves and warp: at warp > 0 and octaves 2 it is roughly 4 noise samples per pixel. On a large wall set octaves to 1 or warp to 0, which degrades to a plain polar noise that still reads well.	bpm — how fast the field drifts.scale — noise cells across the grid; low is broad, high is fine detail.segments — kaleidoscope wedges; 1 disables the fold.warp — domain-warp strength; 0 gives a plain field.octaves — fbm octaves, and the main cost knob.twist — how much the radius shears the angle, setting the spiral.polarTable — read each pixel's angle and radius from a table, 2 bytes each.polarTable16 — hold that table at full precision, at 4 bytes per pixel. Tests: none yet API: reference Details: none yet
SdfShapes 💫🖌️ · 2D A circle and a box orbit and melt into each other, drawn as signed distance fields rather than outlines. One distance per pixel yields three looks at once: a smooth fill, an outline, and a glow falling off into the field. Measured on an ESP32-S3 at 128×128: 20 fps, 728 cycles/pixel using the true-distance form, alongside StarSky (692) and Metaballs (647) at the same size.	bpm — orbit speed.radius — circle radius, as a fraction of the short side.boxSize — box half-extent, same scale.blend — melt radius; 0 unions the shapes hard.outline — 0 fills the shape; higher draws an outline of that width.glow — tint the field around the shape by distance. Tests: none yet API: reference Details: none yet
Solid 💫 · 3D A flat fill with five color modes: a plain RGB(W) color, the active palette spread across the lights, an RMS-averaged single palette color, or the palette banded along the grid's rows or columns.	red / green / blue / white — the flat color in RGB(W) mode.brightness — scales the flat and palette-spread output.colorMode — flat RGB(W), or the palette spread, averaged, or banded.minRGB — in the band modes, drop palette entries darker than this floor.randomColors — in the band modes, shuffle the surviving palette entries. Tests: Solid API: reference Details: none yet
SphereMove 💫 · 3D A hollow spherical shell that bounces through the 3D volume, its surface colored from the palette, leaving no trail.	speed — how fast the sphere moves through the volume. Tests: SphereMove API: reference Details: none yet
Spiral 💫🦅🖌️🎡 · 2D Rotating spiral from angle + distance (atan2_8/dist8).	bpm — rotation speed.twist — how tightly the arm winds (hue gain per unit of distance).hue_shift — rotate the palette index. Tests: Spiral API: reference Details: none yet
StarField 💫🖌️ · 2D A perspective starfield: stars approach the viewer from a vanishing point, brightening as they near, then respawn at depth.	speed — how fast stars approach (frame throttle).numStars — how many stars are active.blur — motion-trail fade per frame.usePalette — color the stars from the palette instead of white. Tests: StarField API: reference Details: none yet
StarSky 💫 · 3D Twinkling stars at random light positions, each fading in and out independently over a dark background.	speed — fade rate per frame (how fast each star brightens/dims).star_fill_ratio — how many stars (as a fraction of the light count).usePalette — color the stars from the active palette instead of white. Tests: StarSky API: reference Details: none yet
Text 💫 · 2D Renders a multi-line string in a bitmap font. Static by default (laid out top-left, each newline dropping one font-height, clipped where it runs off the grid); turn on scroll to march the whole block leftwards as a wrapping marquee. Text color comes from the active palette.	text — the string to show; each line renders on its own row.scroll — off (default) = static; on = horizontal marquee.font — glyph size (4x6 compact, 6x8 larger).speed — marquee speed (only used when scroll is on).hue — palette index for the text color. Tests: Text API: reference Details: none yet

MoonModules effects

Module	Details
GameOfLife 💫🌙🧬 · 2D/3D Conway's cellular automaton generalized to 2D and 3D, with selectable rulesets and custom B#/S#. Cells inherit a neighbor's palette color on birth, dead cells blur toward the background, and the board wraps toroidally. A stasis check respawns a pentomino or glider when the board goes static.	backgroundColorR / G / B — the color dead cells fade toward.ruleset — the birth and survive rule: Conway, HighLife, Maze and others.customRuleString — a custom B#/S# rule, read only when ruleset = Custom.GameSpeed (FPS) — generation rate (0–100, 100 = uncapped).startingLifeDensity — % of cells alive at start (10–90).mutationChance — % chance a newborn gets a random color (0–100).wrap — toroidal edges (cells wrap around).disablePause — skip the 1.5 s settle pause between boards.colorByAge — age from green to red, not a neighbor's palette color.infinite — respawn on stasis (R-pentomino/glider) instead of resetting.blur — dead-cell fade strength toward the background color. Tests: GameOfLife API: reference Details: none yet
GEQ 💫🐙🎶 · 2D A flat graphic equaliser: the 16 audio bands rise as vertical bars from the bottom, with optional smoothing between bars, per-bar palette coloring, and falling peak markers.	fadeOut — how fast bars fade each frame.ripple — falling-peak marker decay.colorBars — color each bar from the palette by band instead of by row.smoothBars — blend neighboring bands for smoother bar heights. Tests: GEQ API: reference Details: none yet
GEQ3D 💫🌙🎶 · 2D A 3D-perspective graphic equaliser: audio bands rise as bars with faked depth, their side/top lines drawn toward a "projector" vanishing point (sweeping left↔right) and shortened by depth. Bands left of the projector are painted right-to-left, bands right of it left-to-right; per-face darkening (side/top/front) and optional borders.	speed — projector sweep rate (1–10, higher = faster).frontFill — bar front-face fill strength (0–255).horizon — vanishing-point row the projector sits on.depth — how far the side/top perspective lines reach toward the projector.numBands — bands shown (2–16, fewer = wider bars).borders — outline each bar. Tests: GEQ3D API: reference Details: none yet
PaintBrush 💫🌙🎶 · 3D Audio-reactive brush strokes: lines whose 3D endpoints oscillate on the beat (beatsin8, audio-band timebase), each stroke shortened to a band-magnitude length so the moving tip sweeps a curve over the fading field.	oscillatorOffset — phase-spread between the oscillating endpoints (0–16).numLines — parallel animated strokes (2–255).fadeRate — background decay per frame (0–128, higher = shorter strokes).minLength — a stroke draws only if longer than this, so quiet bands stay off.color_chaos — per-line random hue vs a per-band gradient.phase_chaos — random per-frame phase jitter. Tests: PaintBrush API: reference Details: none yet
Tetrix 💫🌙✨ · 2D Falling Tetris-style blocks: each column drops a brick that lands on the growing stack, fills the column, then clears and restarts.	speed — fall speed (0 = randomised per brick).width — brick height (0 = randomised).oneColor — one advancing palette color for every brick, not one each. Tests: Tetrix API: reference Details: none yet

WLED effects

Module	Details
Blurz 🐙🎶 · 2D Audio-reactive blurred dots: one frequency band per frame lights a dot whose position maps to that band (or to the major-peak frequency), then the whole frame is blurred for soft trails.	fadeRate — background decay per frame.blur — blur strength applied each frame.freqMap — place the dot by the major-peak frequency, not by scanning.geqScanner — scan the dot across the strip in a GEQ-like sweep. Tests: Blurz API: reference Details: none yet
BouncingBalls 💫🐙 · 2D A row of balls per column bounce under gravity, each losing energy on impact and relaunching when it stops, palette-colored by ball index over a fading background.	grav — gravity strength (higher = faster fall, snappier bounce).numBalls — balls per column (1–16). Tests: BouncingBalls API: reference Details: none yet
FreqMatrix 🐙🎶 · 1D A 1D scrolling frequency display: each frame shifts the strip and injects a new pixel at one end whose hue comes from the dominant frequency and whose brightness from the volume.	speed — scroll rate.fx — sound-effect intensity (scales the injected brightness).lowBin / highBin — the frequency window mapped across the hue range.sensitivity — input gain (10–100).audioSpeed — let the volume modulate the scroll speed. Tests: FreqMatrix API: reference Details: none yet
Lissajous 🐙 · 2D A Lissajous curve traced across the grid from two phase-shifted sin8/cos8 sweeps, palette-colored along its length, with a fading trail.	xFrequency — the x-axis sweep frequency (sets the curve's lobe count).fadeRate — trail fade per frame.speed — how fast the curve's phase advances. Tests: Lissajous API: reference Details: none yet
NoiseMeter 🐙🎵🌫️ · 3D An audio VU meter rendered as a noise bar: the volume sets how many rows light from the bottom, each row colored by drifting Perlin noise, filling the full width and depth.	fadeRate — trail decay per frame (200–254).width — how strongly the volume drives the bar height. Tests: NoiseMeter API: reference Details: none yet
Wave 💫🌫️ · 2D An oscilloscope waveform scrolls across the grid with a fading trail; six selectable shapes.	bpm — travel speed (phase advance per minute).fade — trail fade per frame (0 = instant clear, 255 = long tail).type — waveform shape: sawtooth, triangle, sine, square, sin3 or noise. Tests: Wave API: reference Details: none yet

FastLED effects

Module	Details
Fire ⚡️🦅🧬 · 2D A Fire2012-style heat field: sparks at the base rise and cool through the active palette, coldest at its low end. The spark count scales with the width. The flame color comes from the active palette. For the classic fire look pick the Lava palette (black→red→orange→yellow→white: the recommended default); any palette works, so an Ocean or Forest palette turns the flame blue or green.	cooling — how fast heat dissipates as it rises (higher = shorter flames).sparking — chance of a new spark at the base each frame; higher is livelier. Tests: Fire API: reference Details: none yet
Noise ⚡️💫🌙🐙🌫️ · 1D/2D/3D A gradient-noise field indexed straight into the palette: the plainest way to turn the field into light, and the effect every other noise effect is a variation on.	motion — drift slides the field across the fixture, morph changes it.scale — spatial frequency: low is broad blobs, high is fine detail.bpm — how fast it moves. Tests: Noise API: reference Details: none yet

MoonLight-native effects

Module	Details
MoonLive 📝 · any An effect you write as text on the running device, compiled to native code on the next tick. Pick a script from the library or write your own, and it renders at the speed of a compiled effect. The language is MoonLive.	script — which .mle file runs, picked from the library and edited here.Every control the script declares, editable live without a recompile. Tests: MoonLive API: reference Details: none yet
AudioSpectrum 💫🎶 The 16 mic frequency bands spread across X, each column lit bottom-up by its magnitude.	colorMode — bars colored by height, the VU look, or per-band, a rainbow. Tests: AudioSpectrum API: reference Details: none yet
BeatRipples 💫🎶🖌️ · 2D Every beat is a stone dropped in water. A real wave simulation, which gives what a drawn expanding circle cannot: ripples that pass through each other, reflect off the walls and interfere into standing patterns. The loudest band decides where the stone lands, so a bass hit falls near the center and a treble hit out at the rim, and its strength sets how deep.	damping — how long the water keeps ringing.drop — how deep a beat's stone falls.rain — idle drops when there is no music, so the surface is alive in silence.shine — how strongly the slope lights the surface. Tests: none yet API: reference Details: none yet
Pulse 💫🎶 · 3D Shells expanding from a drifting origin, one per beat: a pair of fronts on a strip, a ring on a panel, a sphere in a volume. Sound fires one and its pitch colors it, and an idle clock keeps them arriving in a silent room. The effect a device boots with. Compare with BeatRipples, which simulates water on a plane. This one draws a moving front, which carries it into 1D and 3D.	bpm — pulses a minute while nothing is heard, where 0 waits for sound alone.speed — how fast a shell crosses the layout, at any layout size.thickness — the shell's width, as a share of the layout rather than in lights.audioGain — how strongly sound fires a pulse, where 0 ignores it.drift — how far the origin wanders from the center, where 0 pins it there. Tests: none yet API: reference Details: none yet
VuMeters 💫🎶🖌️ · 3D Sixteen needles, one per band, each with real mass. What makes a VU meter beautiful is not the dial, it is the needle: it overshoots a peak, swings back and settles, which is why a mechanical meter reads as alive where a bar graph reads as a readout. The bass needles are heavier than the treble ones, so the low end swings and the high end flickers.	damping — how much the needle overshoots; high is a studio meter.response — how hard the needle chases the signal at all.peakHold — how long the peak marker stays up, as a half-life.smooth — drive from the meter ballistic rather than the raw band. Tests: none yet API: reference Details: none yet
RadialSpectrum 💫🎶🖌️🎡 · 3D The spectrum as ripples. Each band owns a sector around the center, mirrored left and right with the bass at top and bottom. Sound is born at the center and travels outward, so the radius is time and a ring's length is that band's recent history. Every sector is one band, so a band that is stuck shows as a sector that never moves. On a cube the ripples are expanding shells.	speed — how fast sound travels outward, a ring every 10 to 105 ms.persistence — how far out a ripple stays visible.smooth — read the meter ballistic rather than the raw bands.beat — a white shockwave born at the center on every onset.polarTable, polarTable16, mapping — the polar address, and its shape. Tests: none yet API: reference Details: none yet
DemoReel 💫 · 3D Plays every other registered effect in turn, auto-advancing on a timer, so one Layer cycles the whole library hands-free. New effects are picked up automatically. It can pick a fresh palette each cycle and overlay the playing effect's name, and the status line says which is playing. It never hosts itself, and it plays in sequence rather than compositing.	interval — seconds each effect plays before advancing (1–120).shuffle — jump to a random next effect instead of registry order.randomPalette — pick a random palette on each cycle; on by default.showName — overlay the playing effect's name in a small font; default on. Tests: DemoReel API: reference Details: none yet
NetworkReceive 📡🌙 Receives lights over UDP and writes them into the layer: the receive side for Resolume, Madrix, xLights and LedFx. Listens for Art-Net, E1.31 and DDP at once. The end-to-end pair with Network Send.	universe_start — the first incoming universe to map, mirroring the sender.channels_per_universe — bytes each universe maps to; 510 or 512. Tests: NetworkReceive API: reference Details: none yet
Sine 💫 · 3D R/G/B each follow a sine along one axis at 120° phase offset: a glowing, scrolling color box.	frequency — spatial frequency, waves across the box (1–20).amplitude — peak brightness (0–255, 255 = full).bpm — scroll speed. Tests: Sine API: reference Details: none yet