gl-transitions/skills/gl-transitions/references/catalog.md

The open collection of GL Transitions

# Catalog (gl-transitions@1.76.1)

125 transitions. Generated from gl-transitions.json; full details (parameter hints, authors, source links) in https://cdn.jsdelivr.net/npm/gl-transitions@1.76.1/llms-full.txt.

## By tag

- **wipe**: BowTieHorizontal, BowTieVertical, BowTieWithParameter, HorizontalClose, HorizontalOpen, Radial, StarWipe, TilesWave, VerticalClose, VerticalOpen, ZoomLeftWipe, ZoomRigthWipe, angular, cannabisleaf, circleopen, directionalwarp, directionalwipe, heart, luma, polar_function, squareswire, static_wipe, undulatingBurnOut, wind, windowslice, wipeDown, wipeLeft, wipeRight, wipeUp
- **blend**: AdvancedMosaic, ColourDistance, CrossZoom, DefocusBlur, Dreamy, GlitchMemories, LinearBlur, Swirl, WaterDrop, coord-from-in, displacement, fade, hexagonalize, kaleidoscope, morph, mosaic_transition, multiply_blend, parametric_glitch, pixelize, ripple, rotateTransition, windowblinds, x_axis_translation
- **zoom**: Box, CrossZoom, DirectionalScaled, DreamyZoom, LeftRight, Mosaic, RectangleCrop, Revolve_Left, RotateScaleVanish, SimpleZoom, SimpleZoomOut, StereoViewer, TopBottom, ZoomInCircles, ZoomLeftWipe, ZoomRigthWipe, crosswarp, rotate_scale_fade, scale-in, zoomInOut
- **slide**: Bounce, Directional, DirectionalScaled, Fold, LeftRight, Slides, TopBottom, directional-easing, splitSlideInHorizontal, splitSlideInOutHorizontal, splitSlideInOutVertical, splitSlideInVertical, splitSlideOutHorizontal, splitSlideOutVertical, tangentMotionBlur, x_axis_translation
- **horizontal**: BowTieHorizontal, Fold, LeftRight, SimpleFlip, ZoomLeftWipe, ZoomRigthWipe, crosswarp, splitSlideInHorizontal, splitSlideInOutHorizontal, splitSlideOutHorizontal, wind, wipeLeft, wipeRight, x_axis_translation
- **fade**: EdgeTransition, HSVfade, Overexposure, SimpleZoom, SimpleZoomOut, burn, colorphase, fade, fadecolor, fadegrayscale, multiply_blend, rotate_scale_fade, scale-in
- **shape**: BowTieHorizontal, BowTieVertical, BowTieWithParameter, Box, CircleCrop, Rectangle, StarWipe, cannabisleaf, circle, heart, polar_function
- **noise**: BlockDissolve, StaticFade, TVStatic, burn0, crosshatch, luminance_melt, perlin, randomNoisex, static_wipe, wind
- **rotate**: DreamyZoom, Revolve_Left, Rolls, RotateScaleVanish, Swirl, cube, pinwheel, rotateTransition, rotate_scale_fade, tangentMotionBlur
- **split**: HorizontalClose, HorizontalOpen, VerticalClose, VerticalOpen, splitSlideInHorizontal, splitSlideInOutHorizontal, splitSlideInOutVertical, splitSlideInVertical, splitSlideOutHorizontal, splitSlideOutVertical
- **vertical**: Bounce, BowTieVertical, TopBottom, splitSlideInOutVertical, splitSlideInVertical, splitSlideOutVertical, squeeze, static_wipe, wipeDown, wipeUp
- **distort**: ButterflyWaveScrawler, CrazyParametricFun, coord-from-in, displacement, flyeye, kaleidoscope, morph, powerKaleido
- **directional**: Directional, DirectionalScaled, Slides, directional-easing, directionalwarp, directionalwipe, squareswire
- **chromatic**: ButterflyWaveScrawler, Drop_Zone_Flicker, GlitchMemories, StripDatamoshGlitch, flyeye, squeeze
- **color**: ColourDistance, HSVfade, burn, colorphase, fadecolor, fadegrayscale
- **glitch**: Drop_Zone_Flicker, GlitchDisplace, GlitchMemories, StripDatamoshGlitch, old_tv_lost_signal, parametric_glitch
- **3d**: BookFlip, InvertedPageCurl, cube, doorway, swap
- **blur**: CrossZoom, DefocusBlur, LinearBlur, Revolve_Left, zoomInOut
- **circle**: CircleCrop, ZoomInCircles, circle, circleopen, undulatingBurnOut
- **dissolve**: BlockDissolve, dissolve, perlin, randomNoisex, randomsquares
- **grid**: GridFlip, PuzzleRight, chessboard, randomsquares, squareswire
- **iris**: CircleCrop, Rectangle, RectangleCrop, circle, circleopen
- **retro**: DoomScreenTransition, StaticFade, StereoViewer, TVStatic, old_tv_lost_signal
- **burn**: FilmBurn, burn0, dissolve, undulatingBurnOut
- **flip**: BookFlip, GridFlip, PuzzleRight, SimpleFlip
- **pixelate**: AdvancedMosaic, hexagonalize, mosaic_transition, pixelize
- **tiles**: GridFlip, Mosaic, PuzzleRight, TilesWave
- **wave**: ButterflyWaveScrawler, Dreamy, TilesWave, ripple
- **box**: Box, Rectangle, RectangleCrop
- **displace**: GlitchDisplace, coord-from-in, displacement
- **flash**: DreamyZoom, Overexposure, burn
- **mosaic**: AdvancedMosaic, Mosaic, mosaic_transition
- **pattern**: PolkaDotsCurtain, chessboard, crosshatch
- **push**: Directional, DirectionalScaled, directional-easing
- **radial**: Radial, angular, pinwheel
- **reflection**: cube, doorway, swap
- **squares**: chessboard, randomsquares, squareswire
- **static**: StaticFade, TVStatic, static_wipe
- **clock**: Radial, angular
- **kaleidoscope**: kaleidoscope, powerKaleido
- **luma**: luma, luminance_melt
- **melt**: DoomScreenTransition, luminance_melt
- **page**: BookFlip, InvertedPageCurl
- **ripple**: WaterDrop, ripple
- **scanlines**: Drop_Zone_Flicker, old_tv_lost_signal
- **spin**: RotateScaleVanish, rotateTransition
- **stripes**: windowblinds, windowslice
- **swirl**: Revolve_Left, Swirl
- **warp**: crosswarp, directionalwarp
- **blinds**: windowblinds
- **blocks**: BlockDissolve
- **bounce**: Bounce
- **cards**: StereoViewer
- **columns**: DoomScreenTransition
- **cube**: cube
- **curl**: InvertedPageCurl
- **datamosh**: StripDatamoshGlitch
- **doors**: doorway
- **dots**: PolkaDotsCurtain
- **edges**: EdgeTransition
- **film**: FilmBurn
- **fire**: burn0
- **flicker**: Drop_Zone_Flicker
- **fold**: Fold
- **fragments**: fragment
- **glow**: dissolve
- **grayscale**: fadegrayscale
- **heart**: heart
- **hexagon**: hexagonalize
- **hue**: HSVfade
- **lens**: flyeye
- **light**: Overexposure
- **light-leak**: FilmBurn
- **lines**: crosshatch
- **mask**: luma
- **morph**: morph
- **motion-blur**: tangentMotionBlur
- **pinwheel**: pinwheel
- **polar**: polar_function
- **psychedelic**: CrazyParametricFun
- **roll**: Rolls
- **shadow**: Bounce
- **shatter**: fragment
- **slices**: windowslice
- **squeeze**: squeeze
- **star**: StarWipe
- **swap**: swap
- **water**: WaterDrop

## Transitions

`name`: description. Parameters as name (type = default). Extra textures are flagged: the host must provide them.

- `AdvancedMosaic`: Both images break into large blocks that blend, then sharpen into the incoming image. Params: pixelSize (float = 50)
- `BlockDissolve`: The incoming image appears in small random blocks. Params: blocksize (float = 0.02)
- `BookFlip`: The outgoing image turns like a book page from right to left, revealing the incoming one
- `Bounce`: The outgoing image drops out of the frame with a few bounces, revealing the incoming one. Params: shadow_colour (vec4 = vec4(0, 0, 0, 0.6)), shadow_height (float = 0.075), bounces (float = 3)
- `BowTieHorizontal`: Two triangles grow from the left and right edges into a bow tie that reveals the incoming image
- `BowTieVertical`: Two triangles grow from the top and bottom edges into a bow tie that reveals the incoming image
- `BowTieWithParameter`: A bow-tie wipe with an adjustable shape that can run in reverse. Params: adjust (float = 0.5), reverse (bool = false)
- `Box`: The outgoing image shrinks into a box, toward the center or a corner, revealing the incoming one. Params: rectIn (int = 1), location (int = 0)
- `ButterflyWaveScrawler`: Wavy, color-separated ripples scramble the outgoing image into the incoming one. Params: amplitude (float = 1), waves (float = 30), colorSeparation (float = 0.3)
- `CircleCrop`: The outgoing image closes into a circle over a background color, then the incoming one opens from it. Params: bgcolor (vec4 = vec4(0, 0, 0, 1))
- `ColourDistance`: Pixels switch to the incoming image in order of how close their colors are. Params: power (float = 5)
- `CrazyParametricFun`: The outgoing image is pulled along a parametric curve into a psychedelic swirl. Params: a (float = 4), b (float = 1), amplitude (float = 120), smoothness (float = 0.1)
- `CrossZoom`: A crossfade through a strong zoom blur. Params: strength (float = 0.4)
- `DefocusBlur`: A crossfade through an out-of-focus blur. Params: blurSize (float = 0.02)
- `Directional`: The incoming image pushes the outgoing one out in a given direction. Params: direction (vec2 = vec2(0, 1))
- `DirectionalScaled`: Like Directional, with both images scaled down while they slide. Params: direction (vec2 = vec2(0, 1)), scale (float = 0.7)
- `DoomScreenTransition`: The outgoing image melts down in uneven columns, like the Doom screen wipe. Params: bars (int = 30), amplitude (float = 2), noise (float = 0.1), frequency (float = 0.5), dripScale (float = 0.5)
- `Dreamy`: A crossfade with a gentle wavy distortion
- `DreamyZoom`: Zooms and rotates into a bright flash, then out to the incoming image. Params: rotation (float = 6), scale (float = 1.2)
- `Drop_Zone_Flicker`: A flickering glitch with RGB offset, ghosting and scanlines that flashes back to the outgoing image. Params: frameRate (float = 24), rgbOffset (float = 0.014), blockAmount (float = 0.72), ghostAmount (float = 0.62), redCyan (float = 0.58), scanline (float = 0.075)
- `EdgeTransition`: Both images fade through black with their edges glowing. Params: edge_thickness (float = 0.001), edge_brightness (float = 8)
- `FilmBurn`: Glowing film-burn light leaks wash over the image and reveal the incoming one. Params: Seed (float = 2.31)
- `Fold`: The incoming image unfolds from the left while the outgoing one folds away to the right
- `GlitchDisplace`: Blocks of the image are displaced in a glitch that flashes into the incoming image
- `GlitchMemories`: A crossfade with glitchy, color-shifted blocks
- `GridFlip`: The image splits into a grid of tiles that flip one by one to the incoming image. Params: size (ivec2 = ivec2(4, 4)), pause (float = 0.1), dividerWidth (float = 0.05), bgcolor (vec4 = vec4(0, 0, 0, 1)), randomness (float = 0.1)
- `HSVfade`: A crossfade through the HSV color space that cycles through hues
- `HorizontalClose`: The incoming image closes in from the top and bottom edges toward the middle
- `HorizontalOpen`: The incoming image opens from a line in the middle toward the top and bottom edges
- `InvertedPageCurl`: The outgoing image curls away like a page, revealing the incoming one
- `LeftRight`: The outgoing image shrinks away to the left while the incoming one slides in from the right
- `LinearBlur`: A crossfade through a blur. Params: intensity (float = 0.1)
- `Mosaic`: The view pans across a mosaic of rotated tiles from both images and settles on the incoming one. Params: endx (int = 2), endy (int = -1)
- `Overexposure`: A crossfade through a washed-out, overexposed white. Params: strength (float = 0.6)
- `PolkaDotsCurtain`: The incoming image appears through growing polka dots. Params: dots (float = 20), center (vec2 = vec2(0, 0))
- `PuzzleRight`: The image splits into a grid of tiles that flip one by one to the incoming image. Params: size (ivec2 = ivec2(4, 4)), pause (float = 0.1), dividerWidth (float = 0.005)
- `Radial`: A radial wipe that sweeps around the center like a clock hand. Params: smoothness (float = 1)
- `Rectangle`: A rectangle grows from the center to cover the outgoing image, then shrinks to reveal the incoming one. Params: bgcolor (vec4 = vec4(0, 0, 0, 1))
- `RectangleCrop`: The outgoing image shrinks into a small rectangle over a background color, then the incoming one grows from it. Params: bgcolor (vec4 = vec4(0, 0, 0, 1))
- `Revolve_Left`: The outgoing image swirls and zooms with motion blur into the incoming one. Params: center (vec2 = vec2(0.46, 0.52)), direction (float = -1), maxRotation (float = 1.95), peakZoom (float = 2.22), swirl (float = 2.85), barrel (float = 0.38), motionBlur (float = 1), switchStart (float = 0.3), switchEnd (float = 0.5), shadow (float = 0.16)
- `Rolls`: The outgoing image rolls away around a corner, revealing the incoming one. Params: type (int = 0), RotDown (bool = false)
- `RotateScaleVanish`: The outgoing image spins and shrinks away over the incoming one. Params: FadeInSecond (bool = true), ReverseEffect (bool = false), ReverseRotation (bool = false)
- `SimpleFlip`: The outgoing image flips around the vertical axis into the incoming one
- `SimpleZoom`: Zooms into the outgoing image, then fades to the incoming one. Params: zoom_quickness (float = 0.8)
- `SimpleZoomOut`: The incoming image zooms out into place while fading in. Params: zoom_quickness (float = 0.8), fade (bool = true)
- `Slides`: The outgoing image slides out, or the incoming one slides in, toward an edge, a corner or the center. Params: type (int = 0), In (bool = false)
- `StarWipe`: A growing star reveals the incoming image. Params: border_thickness (float = 0.01), star_rotation (float = 0.75), border_color (vec4 = vec4(1, 1, 1, 1)), star_center (vec2 = vec2(0.5, 0.5))
- `StaticFade`: Cuts to the incoming image halfway, hidden behind a burst of TV static. Params: n_noise_pixels (float = 200), static_luminosity (float = 0.8)
- `StereoViewer`: Both images shrink into rounded cards that swap, like a stereo viewer toy. Params: zoom (float = 0.88), corner_radius (float = 0.22)
- `StripDatamoshGlitch`: A datamosh glitch: torn strips, chroma shifts and scan noise drag the outgoing image into the incoming one. Params: strength (float = 1), horizontalBars (float = 42), verticalSlits (float = 18), tear (float = 0.18), chroma (float = 0.032), residue (float = 0.62), noiseAmount (float = 0.16), scanAmount (float = 0.13), flashAmount (float = 0.2)
- `Swirl`: Both images swirl around the center while crossfading
- `TVStatic`: Cuts to full-screen TV static, then to the incoming image. Params: offset (float = 0.05)
- `TilesWave`: The incoming image is revealed tile by tile in a diagonal wave. Params: tileCount (ivec2 = ivec2(8, 8)), flipX (bool = true), flipY (bool = false)
- `TopBottom`: The outgoing image shrinks away upward while the incoming one slides in from the bottom
- `VerticalClose`: The incoming image closes in from the left and right edges toward the middle
- `VerticalOpen`: The incoming image opens from a line in the middle toward the left and right edges
- `WaterDrop`: Ripples spread from the center like a drop falling into water, crossfading to the incoming image. Params: amplitude (float = 30), speed (float = 30)
- `ZoomInCircles`: Concentric rings of the outgoing image zoom at different speeds before revealing the incoming one
- `ZoomLeftWipe`: Zooms into the outgoing image, then the incoming one wipes in from right to left. Params: zoom_quickness (float = 0.8)
- `ZoomRigthWipe`: Zooms into the outgoing image, then the incoming one wipes in from left to right. Params: zoom_quickness (float = 0.8)
- `angular`: A wipe that sweeps around the center from a starting angle. Params: startingAngle (float = 90)
- `burn`: A crossfade that brightens toward a color in the middle. Params: color (vec3 = vec3(0.9, 0.4, 0.2))
- `burn0`: The outgoing image burns away in noisy, glowing patches. Params: burnColor (vec3 = vec3(1, 0.5, 0))
- `cannabisleaf`: A cannabis-leaf shape grows from the center to reveal the incoming image
- `chessboard`: A chessboard pattern of squares reveals the incoming image. Params: grid_num (float = 10)
- `circle`: The outgoing image closes into a circle over a background color, then the incoming one opens from it. Params: center (vec2 = vec2(0.5, 0.5)), backColor (vec3 = vec3(0.1, 0.1, 0.1))
- `circleopen`: A soft-edged circle opens from the center to reveal the incoming image. Params: smoothness (float = 0.3), opening (bool = true)
- `colorphase`: A crossfade in which each color channel changes at a different time. Params: fromStep (vec4 = vec4(0, 0.2, 0.4, 0)), toStep (vec4 = vec4(0.6, 0.8, 1, 1))
- `coord-from-in`: A crossfade in which the colors of one image displace the other
- `crosshatch`: The incoming image appears through a crosshatch of lines spreading from the center. Params: center (vec2 = vec2(0.5, 0.5)), threshold (float = 3), fadeEdge (float = 0.1)
- `crosswarp`: The outgoing image zooms in while the incoming one zooms out into place, sweeping from right to left
- `cube`: The two images are faces of a rotating 3D cube, with a floor reflection. Params: persp (float = 0.7), unzoom (float = 0.3), reflection (float = 0.4), floating (float = 3)
- `directional-easing`: Like Directional, with an eased movement. Params: direction (vec2 = vec2(0, 1))
- `directionalwarp`: A diagonal wipe with a warped, smeared edge. Params: smoothness (float = 0.1), direction (vec2 = vec2(-1, 1))
- `directionalwipe`: A soft-edged diagonal wipe. Params: direction (vec2 = vec2(1, -1)), smoothness (float = 0.5)
- `displacement`: A crossfade in which a displacement map (an extra grayscale texture) warps both images. Params: strength (float = 0.5). Extra textures: displacementMap
- `dissolve`: The incoming image spreads over the outgoing one with a hot, glowing edge. Params: uLineWidth (float = 0.1), uSpreadClr (vec3 = vec3(1, 0, 0)), uHotClr (vec3 = vec3(0.9, 0.9, 0.2)), uPow (float = 5), uIntensity (float = 1)
- `doorway`: The outgoing image opens like double doors as the incoming one comes forward, with a floor reflection. Params: reflection (float = 0.4), perspective (float = 0.4), depth (float = 3)
- `fade`: A linear crossfade between the two images
- `fadecolor`: A fade through a solid color, black by default. Params: color (vec3 = vec3(0, 0, 0)), colorPhase (float = 0.4)
- `fadegrayscale`: A crossfade through grayscale. Params: intensity (float = 0.3)
- `flyeye`: The image breaks into a fly's-eye grid of lenses with color separation. Params: size (float = 0.04), zoom (float = 50), colorSeparation (float = 0.3)
- `fragment`: The outgoing image shatters into fragments that fly away
- `heart`: A heart shape grows from the center to reveal the incoming image
- `hexagonalize`: Both images turn into hexagons, crossfade, then sharpen again. Params: steps (int = 50), horizontalHexagons (float = 20)
- `kaleidoscope`: A crossfade through a spinning kaleidoscope. Params: speed (float = 1), angle (float = 1), power (float = 1.5)
- `luma`: A wipe that follows the brightness of a grayscale mask (the luma texture). Extra textures: luma
- `luminance_melt`: The outgoing image melts away in noisy vertical streaks, depending on its brightness. Params: direction (bool = true), l_threshold (float = 0.8), above (bool = false)
- `morph`: A crossfade in which each image is displaced by the other's colors, like a morph. Params: strength (float = 0.1)
- `mosaic_transition`: Both images break into mosaic blocks that blend, then sharpen into the incoming image. Params: mosaicNum (float = 10)
- `multiply_blend`: A crossfade through the multiplied blend of both images
- `old_tv_lost_signal`: A crossfade with drifting tracking lines and tearing, like a TV losing its signal
- `parametric_glitch`: A crossfade with glitchy horizontal bands and color shifts. Params: ampx (float = 1), ampy (float = 1)
- `perlin`: The incoming image appears through blobs of Perlin noise. Params: scale (float = 4), smoothness (float = 0.01), seed (float = 12.9898)
- `pinwheel`: A spinning pinwheel reveals the incoming image. Params: speed (float = 2)
- `pixelize`: Both images pixelate, crossfade, then sharpen again. Params: squaresMin (ivec2 = ivec2(20, 20)), steps (int = 50)
- `polar_function`: A flower shape with several petals grows to reveal the incoming image. Params: segments (int = 5)
- `powerKaleido`: The image folds into an animated kaleidoscope before revealing the incoming one. Params: scale (float = 2), z (float = 1.5), speed (float = 5)
- `randomNoisex`: The incoming image appears pixel by pixel in random noise
- `randomsquares`: The incoming image appears in random squares. Params: size (ivec2 = ivec2(10, 10)), smoothness (float = 0.5)
- `ripple`: Ripples spread from the center while crossfading. Params: amplitude (float = 100), speed (float = 50)
- `rotateTransition`: The images spin around the center while crossfading
- `rotate_scale_fade`: The outgoing image spins and zooms while fading to the incoming one, over a background color. Params: center (vec2 = vec2(0.5, 0.5)), rotations (float = 1), scale (float = 8), backColor (vec4 = vec4(0.15, 0.15, 0.15, 1))
- `scale-in`: The incoming image scales in from the center while fading in
- `splitSlideInHorizontal`: The incoming image slides in as two halves moving horizontally in opposite directions. Params: reverse (bool = false)
- `splitSlideInOutHorizontal`: The halves of both images slide horizontally in opposite directions, out and in at once. Params: reverse (bool = false)
- `splitSlideInOutVertical`: The halves of both images slide vertically in opposite directions, out and in at once. Params: reverse (bool = false)
- `splitSlideInVertical`: The incoming image slides in as two halves moving vertically in opposite directions. Params: reverse (bool = false)
- `splitSlideOutHorizontal`: The outgoing image slides out as two halves moving horizontally in opposite directions. Params: reverse (bool = false)
- `splitSlideOutVertical`: The outgoing image slides out as two halves moving vertically in opposite directions. Params: reverse (bool = false)
- `squareswire`: Squares grow along a diagonal sweep to reveal the incoming image. Params: squares (ivec2 = ivec2(10, 10)), direction (vec2 = vec2(1, -0.5)), smoothness (float = 1.6)
- `squeeze`: The outgoing image is squeezed into a line with color separation, revealing the incoming one. Params: colorSeparation (float = 0.04)
- `static_wipe`: A wipe from top to bottom with a band of TV static at its edge. Params: u_transitionUpToDown (bool = true), u_max_static_span (float = 0.5)
- `swap`: The two images swap places in 3D, with a floor reflection. Params: reflection (float = 0.4), perspective (float = 0.2), depth (float = 3)
- `tangentMotionBlur`: The outgoing image is flung away along a curve with motion blur
- `undulatingBurnOut`: A circle with a wavy edge burns out from the center to reveal the incoming image. Params: smoothness (float = 0.03), center (vec2 = vec2(0.5, 0.5)), color (vec3 = vec3(0, 0, 0))
- `wind`: A ragged left-to-right wipe, as if the image was blown away by the wind. Params: size (float = 0.2), reversed (bool = false)
- `windowblinds`: A crossfade through horizontal window blinds
- `windowslice`: The incoming image appears through vertical slices that widen. Params: count (float = 10), smoothness (float = 0.5)
- `wipeDown`: A hard-edged wipe from top to bottom
- `wipeLeft`: A hard-edged wipe from right to left
- `wipeRight`: A hard-edged wipe from left to right
- `wipeUp`: A hard-edged wipe from bottom to top
- `x_axis_translation`: The outgoing image slides to the right, uncovering a crossfade to the incoming one
- `zoomInOut`: Zooms into the outgoing image until it blurs into a flat color, then out to the incoming one