A single import — package:flutter_shaders_ui/flutter_shaders_ui.dart — brings in the whole public surface: three core building blocks, one callback typedef, and ten drop-in effect widgets. Nothing else is exported; the shaders themselves ship as bundled .frag assets.

Every effect is a plain widget you drop into your tree. Their constructor signatures are listed below for quick reference. For the full parameter tables — ranges, defaults and per-parameter notes — plus a working example for each, see the Effects reference.

const WaveBackground({
  super.key,
  this.child,
  this.color1 = const Color(0xFF1A237E),
  this.color2 = const Color(0xFF00BCD4),
  this.amplitude = 0.3,
  this.frequency = 2.0,
  this.speed = 1.0,
  this.enabled = true,
})

const WaterEffect({
  super.key,
  this.child,
  this.color1 = const Color(0xFF26C6DA),
  this.color2 = const Color(0xFF0D47A1),
  this.speed = 1.0,
  this.depth = 0.5,
  this.waveIntensity = 0.5,
  this.causticIntensity = 0.6,
  this.foamAmount = 0.0,
  this.enabled = true,
})

const AuroraEffect({
  super.key,
  this.child,
  this.color1 = const Color(0xFF00E676),
  this.color2 = const Color(0xFFAA00FF),
  this.intensity = 0.6,
  this.speed = 1.0,
  this.enabled = true,
})

const FireEffect({
  super.key,
  this.child,
  this.intensity = 0.6,
  this.speed = 1.0,
  this.color1 = const Color(0xFFFFEB3B),
  this.color2 = const Color(0xFFFF5722),
  this.enabled = true,
})

const GlassEffect({
  super.key,
  this.child,
  this.blurAmount = 0.5,
  this.frost = 0.4,
  this.opacity = 0.3,
  this.tint = const Color(0xFFFFFFFF),
  this.enabled = true,
})

const PulseEffect({
  super.key,
  this.child,
  this.color = const Color(0xFF2196F3),
  this.speed = 1.0,
  this.intensity = 0.5,
  this.enabled = true,
})

const ShimmerEffect({
  super.key,
  this.child,
  this.color = const Color(0x40FFFFFF),
  this.angle = 0.5,
  this.speed = 1.0,
  this.width = 0.3,
  this.enabled = true,
})

const SnowEffect({
  super.key,
  this.child,
  this.density = 0.5,
  this.speed = 1.0,
  this.size = 0.5,
  this.enabled = true,
})

const RippleEffect({
  super.key,
  required this.child,
  this.color = Colors.white,
  this.duration = _defaultRippleDuration,
  this.intensity = _defaultRippleIntensity,
  this.onTap,
})

const GlowOrb({
  super.key,
  this.position = const Offset(0.5, 0.5),
  this.color = Colors.cyan,
  this.radius = _defaultRadius,
  this.glowIntensity = _defaultGlowIntensity,
  this.pulseSpeed = _defaultPulseSpeed,
  this.enabled = true,
  this.child,
})

const GlowOrb.bouncing({
  super.key,
  this.color = Colors.purple,
  this.radius = _defaultRadius,
  this.glowIntensity = _defaultGlowIntensity,
  this.pulseSpeed = _defaultPulseSpeed,
  this.enabled = true,
  this.child,
  double speed = _defaultBounceSpeed,
})

const GlowOrb.draggable({
  super.key,
  this.position = const Offset(0.5, 0.5),
  this.color = Colors.orange,
  this.radius = _defaultRadius,
  this.glowIntensity = _defaultGlowIntensity,
  this.pulseSpeed = _defaultPulseSpeed,
  this.enabled = true,
  this.child,
})

The base widget behind every effect. It loads a .frag asset through ShaderCache, runs a Ticker for the time animation, wraps the paint in a RepaintBoundary, and feeds the shader its standard uniforms. Build your own effects on top of it — see Custom shaders.

const ShaderEffectWidget({
  super.key,
  required this.assetPath,
  this.child,
  this.uniformSetter,
  this.enabled = true,
  this.showAsOverlay = false,
  this.timeScale = 1.0,
})

ShaderEffectWidget(
  assetPath: 'packages/flutter_shaders_ui/shaders/snow.frag',
  child: Text('Hello'),
)

A global, static cache for compiled ui.FragmentProgram instances, keyed by asset path — this is what makes "compiled once" true across your whole app. It has a private constructor (ShaderCache._()), so you never instantiate it; you call its static methods. Concurrent loads of the same path are deduplicated: a second load that arrives mid-compile awaits the same in-flight future rather than compiling again. It is thread-safe for single-isolate Flutter usage.

static Future<ui.FragmentProgram> load(String assetPath)
static void evict(String assetPath)
static void clearAll()

final program = await ShaderCache.load('shaders/snow.frag');
final shader = program.fragmentShader();

A bare CustomPainter that fills its canvas rect with a ui.FragmentShader. It does no loading and no animation of its own — the contract is that you set the shader's uniforms before it paints. Pass a Listenable to repaint (for example an AnimationController or a ValueNotifier) to drive repaints; shouldRepaint always returns true. Reach for it when you want a shader on a canvas without the full ShaderEffectWidget lifecycle.

ShaderPainter({
  required this.shader,
  super.repaint,
})

The package exports one support type, the ShaderUniformSetter typedef used by ShaderEffectWidget.uniformSetter. There are no public enums.

typedef ShaderUniformSetter = int Function(
  ui.FragmentShader shader,
  Size size,
  double time,
  int index,
);

The callback runs every frame. It receives the live shader, the current widget size (logical pixels), the elapsed time in seconds, and the starting uniform index (which is 3, right after the standard uniforms). Set your floats with shader.setFloat(...) starting at that index, then return the next available index so the framework knows where your uniforms ended. Colors are passed as three separate floats — color.r, color.g, color.b.

Every effect degrades to its child, never to a crash. Three cases are worth knowing.

• Disabled (enabled: false). ShaderEffectWidget.build returns child ?? const SizedBox.shrink() and the animation Ticker is stopped, so there is zero GPU cost. Every effect widget forwards its own enabled flag down to this guard — wire it to a reduced-motion setting for accessibility.
• While loading. Until the FragmentProgram finishes loading the widget renders only its child (the same fallback), and the Ticker starts only once the program has loaded and enabled is true. A missing or invalid .frag asset leaves the program null, so the effect simply never appears and your child keeps rendering — the layout is never torn down.
• RippleEffect idle cost. It has no enabled parameter; its internal shader is active only while a tap animation runs and switches off when the animation completes, so between taps it too renders only the child.