Event Horizon
Thousands of hairline streams of light flow around a still, dark void, drawn as real flow around an obstacle: white and rose near the edge, cold blue further out, a thin bright ring at the rim and a soft band of light across the front, with light running along every line. Your cursor is a second lens that bends the streams round it, a click ripples through every line, scrolling draws you toward the void, and when idle the field sways and flows.
Tweak
LIVELIVELight
Field
Motion
Interactive
The cursor bends the streams, clicks send a ripple
Usage
Follows your tweaks.
import { EventHorizon } from "@/components/inreact/event-horizon";
export function Hero() {
return (
<EventHorizon
className="h-screen w-full"
>
{/* optional: your hero content, drawn above the streams */}
</EventHorizon>
);
}Install with the CLI
npx shadcn@latest add https://inreact.vercel.app/r/event-horizon.jsonOr copy the source
Install the dependencies, then save this as components/inreact/event-horizon.tsx.
npm install gsap"use client";
import { gsap } from "gsap";
import { ScrollTrigger } from "gsap/ScrollTrigger";
import { useEffect, useRef, type ReactNode } from "react";
gsap.registerPlugin(ScrollTrigger);
/**
* Event Horizon: hairline streams of light flowing around a dark void.
*
* Thousands of fine silk-like streamlines sweep in from one side, arch around a
* still, dark lens and pour away on the other, drawn as real flow around an
* obstacle. Near the void they run white and rose, further out a cold blue
* fading to navy; a thin bright ring traces the edge and a soft band of light
* crosses in front. Light travels along every line, so the whole field flows.
* A real bloom pass lets the brightest streams glow; the void stays black.
*
* It reacts: your cursor is a second, smaller lens, so the streams bend around
* it as you move; a click sends a ripple running out through every line;
* scrolling draws you toward the void. On load the streams spin up out of the
* dark. When idle the field breathes and flows on its own.
*
* <EventHorizon className="h-screen w-full">
* <YourHero />
* </EventHorizon>
*
* WebGL: one shader (stream function of flow round the void, antialiased
* hairlines, travelling light), then bloom at 1/4 and 1/16 size. GSAP drives
* every motion. Pauses off-screen; reduced motion shows a still frame; a CSS
* gradient without WebGL.
*/
export interface EventHorizonProps {
/** Colour of the streams nearest the void. */
inner?: string;
/** Colour of the streams further out. */
outer?: string;
/** Background colour. */
background?: string;
/** Size of the void. */
size?: number;
/** How many streams. */
density?: number;
/** Brightness. */
intensity?: number;
/** Strength of the bloom. */
glow?: number;
/** Speed of the flow. */
speed?: number;
/** Cursor lens, click ripple. */
interactive?: boolean;
/** Scroll container if the page does not scroll the window. */
scroller?: Element | null;
/** Foreground content, drawn above the streams. */
children?: ReactNode;
className?: string;
}
const QUAD = `attribute vec2 aQ; varying vec2 vUv; void main(){ vUv = aQ * 0.5 + 0.5; gl_Position = vec4(aQ, 0.0, 1.0); }`;
const SCENE = `
#extension GL_OES_standard_derivatives : enable
precision highp float;
uniform vec2 uRes, uCenter, uMouse, uRipC;
uniform float uTime, uFlow, uIn, uR, uTilt, uZoom, uDensity, uIntensity, uHover, uRip, uRipAmp, uBreath;
uniform vec3 uInner, uOuter, uBg;
varying vec2 vUv;
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
float vnoise(vec2 p) {
vec2 i = floor(p), f = fract(p);
f = f * f * (3.0 - 2.0 * f);
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x), mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
}
void main() {
float H = uRes.y;
vec2 p = gl_FragCoord.xy / H;
// the cursor is a second, smaller lens: space near it is pulled in, so the streams bend round it
vec2 dm = p - uMouse;
float md2 = dot(dm, dm);
p -= dm * 0.55 * exp(-md2 / 0.012) * uHover;
// a click's ripple pushes space outward in a running ring
vec2 dr = p - uRipC;
float rl = length(dr);
float ring = exp(-pow((rl - uRip * 1.4) / 0.06, 2.0)) * uRipAmp;
p += (dr / max(rl, 1e-4)) * ring * 0.03;
// into the void's frame: tilted, gently flattened like a disk seen at an angle, zoomed by scroll
vec2 q = (p - uCenter) / uZoom;
float c = cos(uTilt), s = sin(uTilt);
q = mat2(c, -s, s, c) * q;
q.y /= 0.82;
float R = uR * (1.0 + 0.02 * sin(uTime * 0.4) * uBreath);
float r2 = max(dot(q, q), 1e-6);
float r = sqrt(r2);
// flow round a cylinder: psi labels the streamline, phi runs along it
float k = R * R / r2;
float psi = q.y * (1.0 - k);
float phi = q.x * (1.0 + k);
// the streams stay mostly on one side, curling as they leave
psi += 0.05 * sin(phi * 2.2 - uFlow * 0.25) * smoothstep(0.0, 0.6, abs(q.x));
float N = 150.0 * uDensity;
float lv = psi * N;
float id = floor(lv + 0.5);
float hid = hash(vec2(id, 3.7));
float f = abs(fract(lv + 0.5) - 0.5);
float fw = max(fwidth(lv), 1e-4);
float line = 1.0 - smoothstep(0.0, fw * 1.1, f);
// where lines crowd tighter than a pixel, blend to their average so nothing aliases
line = mix(line, 0.35, smoothstep(0.35, 0.8, fw));
// light travels along every line: bright runs and gaps sliding with the flow
float run = vnoise(vec2(phi * 3.0 - uFlow * (0.6 + hid * 0.6), id * 0.37));
run = 0.25 + 0.95 * smoothstep(0.3, 0.85, run);
// brightest close to the void, fading with distance from it
float near = exp(-abs(psi) / 0.11);
float around = exp(-max(r - R, 0.0) / 0.55);
float b = line * run * (0.15 + 1.1 * near) * around * (0.55 + 0.6 * hid);
// colour: white-rose hugging the void, cold blue further out, a scatter of lines in between
vec3 col = mix(uOuter, uInner, smoothstep(0.02, 0.16, near * 0.25 + exp(-abs(psi) / 0.05) * 0.7));
col = mix(col, vec3(1.0, 0.97, 0.98), exp(-abs(psi) / 0.025) * 0.7);
col = mix(col, uOuter * 1.2, step(0.86, hid) * 0.6);
vec3 L = col * b;
// the thin bright ring tracing the edge, and the band of light crossing in front of it
float edge = exp(-pow((r - R) / 0.006, 2.0)) + 0.35 * exp(-pow((r - R * 1.04) / 0.012, 2.0));
L += mix(uInner, vec3(1.0), 0.6) * edge * (0.55 + 0.45 * smoothstep(-0.3, 0.6, q.x - q.y));
vec2 bq = q - vec2(0.12, -R * 0.95);
float band = exp(-pow(bq.y / 0.07, 2.0) - pow(bq.x / 0.55, 2.0));
L += mix(uOuter, vec3(1.0), 0.55) * band * (0.4 + 0.6 * run) * 0.85;
// the void: still and black, its edge softened by a hair
float inside = smoothstep(R * 0.985, R * 0.94, r);
L *= 1.0 - inside;
// the ripple lights the lines it passes
L += col * line * ring * 0.8;
// on load the streams spin up out of the dark, nearest the void first
L *= smoothstep(0.0, 0.5, uIn * 1.6 - abs(psi) * 1.2);
gl_FragColor = vec4(uBg + L * uIntensity, 1.0);
}`;
const BLUR = `
precision mediump float;
uniform sampler2D uTex;
uniform vec2 uStep;
varying vec2 vUv;
void main() {
vec4 c = texture2D(uTex, vUv) * 0.2270;
c += (texture2D(uTex, vUv + uStep * 1.3846) + texture2D(uTex, vUv - uStep * 1.3846)) * 0.3162;
c += (texture2D(uTex, vUv + uStep * 3.2308) + texture2D(uTex, vUv - uStep * 3.2308)) * 0.0703;
gl_FragColor = c;
}`;
const BRIGHT = `
precision mediump float;
uniform sampler2D uTex;
varying vec2 vUv;
void main() {
vec3 c = texture2D(uTex, vUv).rgb;
float l = max(c.r, max(c.g, c.b));
gl_FragColor = vec4(c * smoothstep(0.45, 0.95, l), 1.0);
}`;
const COMPOSITE = `
precision mediump float;
uniform sampler2D uScene, uBloom, uWide;
uniform float uGlow, uTime;
varying vec2 vUv;
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
void main() {
vec3 sc = texture2D(uScene, vUv).rgb;
vec3 bl = texture2D(uBloom, vUv).rgb * 0.6 + texture2D(uWide, vUv).rgb * 0.5;
vec3 x = sc + bl * uGlow;
vec3 col = x / (1.0 + max(x - 0.85, 0.0) * 1.3);
col = min(col, vec3(1.0));
col += (hash(gl_FragCoord.xy + fract(uTime * 7.0) * 91.0) - 0.5) / 255.0;
gl_FragColor = vec4(col, 1.0);
}`;
const isReducedMotion = () =>
typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
function rgb(hex: string): [number, number, number] {
let h = hex.replace("#", "");
if (h.length === 3) h = h.replace(/./g, (c) => c + c);
const n = parseInt(h, 16) || 0;
return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255];
}
export function EventHorizon({
inner = "#f3c9cf",
outer = "#4f73c9",
background = "#000000",
size = 1,
density = 1,
intensity = 1,
glow = 0.8,
speed = 1,
interactive = true,
scroller,
children,
className,
}: EventHorizonProps) {
const hostRef = useRef<HTMLDivElement>(null);
const props = useRef({ inner, outer, background, size, density, intensity, glow, speed, interactive });
const redraw = useRef<(() => void) | null>(null);
useEffect(() => {
props.current = { inner, outer, background, size, density, intensity, glow, speed, interactive };
redraw.current?.();
}, [inner, outer, background, size, density, intensity, glow, speed, interactive]);
useEffect(() => {
const host = hostRef.current;
if (!host) return;
if (getComputedStyle(host).position === "static") host.style.position = "relative";
const still = isReducedMotion();
const canvas = document.createElement("canvas");
canvas.setAttribute("aria-hidden", "true");
canvas.style.cssText = "position:absolute;inset:0;width:100%;height:100%;display:block;touch-action:pan-y;";
host.prepend(canvas);
const gl = canvas.getContext("webgl", { alpha: false, antialias: false, powerPreference: "high-performance" });
if (!gl) {
const p = props.current;
host.style.background = `radial-gradient(circle at 55% 50%, ${p.background} 15%, ${p.inner}66 17%, ${p.outer}44 30%, ${p.background} 55%)`;
canvas.remove();
return;
}
gl.getExtension("OES_standard_derivatives");
const build = (fs: string) => {
const pr = gl.createProgram()!;
for (const [type, src] of [
[gl.VERTEX_SHADER, QUAD],
[gl.FRAGMENT_SHADER, fs],
] as const) {
const sh = gl.createShader(type)!;
gl.shaderSource(sh, src);
gl.compileShader(sh);
if (!gl.getShaderParameter(sh, gl.COMPILE_STATUS)) console.error(gl.getShaderInfoLog(sh));
gl.attachShader(pr, sh);
}
gl.linkProgram(pr);
if (!gl.getProgramParameter(pr, gl.LINK_STATUS)) console.error(gl.getProgramInfoLog(pr));
return pr;
};
const sceneProg = build(SCENE);
const blurProg = build(BLUR);
const brightProg = build(BRIGHT);
const compProg = build(COMPOSITE);
const uni = (pr: WebGLProgram, names: string[]) =>
Object.fromEntries(names.map((n) => [n, gl.getUniformLocation(pr, n)])) as Record<string, WebGLUniformLocation | null>;
const US = uni(sceneProg, ["uRes", "uCenter", "uMouse", "uRipC", "uTime", "uFlow", "uIn", "uR", "uTilt", "uZoom", "uDensity", "uIntensity", "uHover", "uRip", "uRipAmp", "uBreath", "uInner", "uOuter", "uBg"]);
const UB = uni(blurProg, ["uTex", "uStep"]);
const UR = uni(brightProg, ["uTex"]);
const UC = uni(compProg, ["uScene", "uBloom", "uWide", "uGlow", "uTime"]);
const quad = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, quad);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);
const drawQuad = (pr: WebGLProgram) => {
const a = gl.getAttribLocation(pr, "aQ");
gl.bindBuffer(gl.ARRAY_BUFFER, quad);
gl.enableVertexAttribArray(a);
gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0);
gl.drawArrays(gl.TRIANGLES, 0, 3);
gl.disableVertexAttribArray(a);
};
type Target = { fb: WebGLFramebuffer; tex: WebGLTexture; w: number; h: number };
const target = (tw: number, th: number): Target => {
const tex = gl.createTexture()!;
gl.bindTexture(gl.TEXTURE_2D, tex);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, tw, th, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
const fb = gl.createFramebuffer()!;
gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
return { fb, tex, w: tw, h: th };
};
let T: { scene: Target; a: Target; b: Target; c: Target; d: Target } | null = null;
const freeTargets = () => {
if (!T) return;
for (const x of Object.values(T)) {
gl.deleteFramebuffer(x.fb);
gl.deleteTexture(x.tex);
}
T = null;
};
let w = 1, h = 1, dpr = 1;
const resize = () => {
dpr = Math.min(window.devicePixelRatio || 1, 2);
w = Math.max(1, host.clientWidth);
h = Math.max(1, host.clientHeight);
canvas.width = Math.round(w * dpr);
canvas.height = Math.round(h * dpr);
const sw = canvas.width, sh = canvas.height;
freeTargets();
T = {
scene: target(sw, sh),
a: target(Math.max(1, sw >> 2), Math.max(1, sh >> 2)),
b: target(Math.max(1, sw >> 2), Math.max(1, sh >> 2)),
c: target(Math.max(1, sw >> 4), Math.max(1, sh >> 4)),
d: target(Math.max(1, sw >> 4), Math.max(1, sh >> 4)),
};
};
resize();
// ---- state: every value GSAP moves (positions in height units, y up) ----
const s = { in: still ? 1 : 0, zoom: still ? 1 : 0.85, push: 0, tilt: -0.42, sway: 0, cx: 0, cy: 0, mx: -9, my: -9, hover: 0, rip: 0, ripAmp: 0, rx: 0, ry: 0, breath: 1, rush: 0 };
let time = still ? 5 : 0, flow = still ? 5 : 0;
const blurPass = (src: Target, dst: Target, dx: number, dy: number) => {
gl.bindFramebuffer(gl.FRAMEBUFFER, dst.fb);
gl.viewport(0, 0, dst.w, dst.h);
gl.useProgram(blurProg);
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, src.tex);
gl.uniform1i(UB.uTex, 0);
gl.uniform2f(UB.uStep, dx / src.w, dy / src.h);
drawQuad(blurProg);
};
const draw = () => {
if (!T) return;
const p = props.current;
const X = T;
const aspect = w / h;
gl.bindFramebuffer(gl.FRAMEBUFFER, X.scene.fb);
gl.viewport(0, 0, X.scene.w, X.scene.h);
gl.useProgram(sceneProg);
gl.uniform2f(US.uRes, X.scene.w, X.scene.h);
// the void sits a little right of centre on wide screens, centred on narrow ones, leaving room for content
const off = Math.min(0.18, Math.max(0, (aspect - 1) * 0.12));
gl.uniform2f(US.uCenter, aspect * 0.5 + off * aspect * 0.5 + s.cx, 0.5 + s.cy);
gl.uniform2f(US.uMouse, s.mx, s.my);
gl.uniform2f(US.uRipC, s.rx, s.ry);
gl.uniform1f(US.uTime, time);
gl.uniform1f(US.uFlow, flow);
gl.uniform1f(US.uIn, s.in);
gl.uniform1f(US.uR, 0.17 * p.size);
gl.uniform1f(US.uTilt, s.tilt + s.sway);
gl.uniform1f(US.uZoom, s.zoom + s.push);
gl.uniform1f(US.uDensity, p.density);
gl.uniform1f(US.uIntensity, p.intensity);
gl.uniform1f(US.uHover, s.hover);
gl.uniform1f(US.uRip, s.rip);
gl.uniform1f(US.uRipAmp, s.ripAmp);
gl.uniform1f(US.uBreath, s.breath);
gl.uniform3fv(US.uInner, rgb(p.inner));
gl.uniform3fv(US.uOuter, rgb(p.outer));
gl.uniform3fv(US.uBg, rgb(p.background));
drawQuad(sceneProg);
gl.bindFramebuffer(gl.FRAMEBUFFER, X.a.fb);
gl.viewport(0, 0, X.a.w, X.a.h);
gl.useProgram(brightProg);
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, X.scene.tex);
gl.uniform1i(UR.uTex, 0);
drawQuad(brightProg);
blurPass(X.a, X.b, 1, 0);
blurPass(X.b, X.a, 0, 1);
blurPass(X.a, X.c, 1, 0);
blurPass(X.c, X.d, 0, 1);
blurPass(X.d, X.c, 1.8, 0);
blurPass(X.c, X.d, 0, 1.8);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
gl.viewport(0, 0, canvas.width, canvas.height);
gl.useProgram(compProg);
[X.scene.tex, X.a.tex, X.d.tex].forEach((tex, i) => {
gl.activeTexture(gl.TEXTURE0 + i);
gl.bindTexture(gl.TEXTURE_2D, tex);
});
gl.uniform1i(UC.uScene, 0);
gl.uniform1i(UC.uBloom, 1);
gl.uniform1i(UC.uWide, 2);
gl.uniform1f(UC.uGlow, p.glow);
gl.uniform1f(UC.uTime, time);
drawQuad(compProg);
gl.activeTexture(gl.TEXTURE0);
};
const ro = new ResizeObserver(() => {
resize();
draw();
});
ro.observe(host);
if (still) {
draw();
redraw.current = draw;
return () => {
redraw.current = null;
ro.disconnect();
freeTargets();
canvas.remove();
gl.getExtension("WEBGL_lose_context")?.loseContext();
};
}
// ---- on load: the streams spin up out of the dark as the view settles ----
const intro = gsap
.timeline({ delay: 0.1 })
.to(s, { in: 1, duration: 3, ease: "power2.inOut" }, 0)
.to(s, { zoom: 1, duration: 3.6, ease: "expo.out" }, 0)
.fromTo(s, { rush: 6 }, { rush: 0, duration: 3.2, ease: "power3.out" }, 0);
// ---- idle: the field sways and the void drifts a little, so it is never still ----
const sway = gsap.to(s, { sway: 0.08, duration: 7, ease: "sine.inOut", yoyo: true, repeat: -1 });
const drift = gsap
.timeline({ repeat: -1, yoyo: true })
.to(s, { cx: 0.02, cy: 0.015, duration: 6, ease: "sine.inOut" })
.to(s, { cx: -0.015, cy: -0.01, duration: 6.5, ease: "sine.inOut" });
// ---- cursor: a second lens that bends the streams round it, and the void leans toward it ----
const mxTo = gsap.quickTo(s, "mx", { duration: 0.6, ease: "power3" });
const myTo = gsap.quickTo(s, "my", { duration: 0.6, ease: "power3" });
const hoverTo = gsap.quickTo(s, "hover", { duration: 0.8, ease: "power2.out" });
const local = (e: PointerEvent) => {
const r = host.getBoundingClientRect();
return { x: (e.clientX - r.left) / r.height, y: (r.bottom - e.clientY) / r.height };
};
let first = true;
const move = (e: PointerEvent) => {
if (!props.current.interactive) return;
const p = local(e);
if (first) {
gsap.set(s, { mx: p.x, my: p.y });
first = false;
}
mxTo(p.x);
myTo(p.y);
hoverTo(1);
};
const leave = () => {
first = true;
hoverTo(0);
};
// ---- click: a ripple runs out through every stream ----
const down = (e: PointerEvent) => {
if (!props.current.interactive) return;
const p = local(e);
s.rx = p.x;
s.ry = p.y;
gsap.killTweensOf(s, "rip,ripAmp");
gsap.fromTo(s, { rip: 0 }, { rip: 1, duration: 2, ease: "power2.out" });
gsap.timeline().fromTo(s, { ripAmp: 0 }, { ripAmp: 1, duration: 0.15, ease: "power2.out" }).to(s, { ripAmp: 0, duration: 1.8, ease: "power2.in" });
gsap.fromTo(s, { rush: 3 }, { rush: 0, duration: 1.6, ease: "power3.out", overwrite: "auto" });
};
host.addEventListener("pointermove", move);
host.addEventListener("pointerleave", leave);
host.addEventListener("pointerdown", down);
// ---- scroll: draw toward the void, the flow quickening with the scroll ----
const pushTo = gsap.quickTo(s, "push", { duration: 1.3, ease: "power3" });
const st = ScrollTrigger.create({
trigger: host,
scroller: scroller ?? undefined,
start: "top bottom",
end: "bottom top",
onUpdate: (self) => pushTo(Math.max(0, self.progress - 0.5) * 1.2),
});
// ---- loop, only while on screen ----
let visible = true;
let prev = performance.now();
const loop = () => {
const now = performance.now();
const dt = Math.min(0.05, (now - prev) / 1000);
prev = now;
if (!visible) return;
time += dt;
flow += dt * props.current.speed * (1 + s.rush);
draw();
};
const io = new IntersectionObserver(([en]) => {
visible = en.isIntersecting;
prev = performance.now();
});
io.observe(host);
gsap.ticker.add(loop);
return () => {
gsap.ticker.remove(loop);
intro.kill();
sway.kill();
drift.kill();
st.kill();
io.disconnect();
ro.disconnect();
host.removeEventListener("pointermove", move);
host.removeEventListener("pointerleave", leave);
host.removeEventListener("pointerdown", down);
gsap.killTweensOf(s);
freeTargets();
canvas.remove();
gl.getExtension("WEBGL_lose_context")?.loseContext();
};
}, [scroller]);
return (
<div ref={hostRef} className={["isolate overflow-hidden", className].filter(Boolean).join(" ")} style={{ background }}>
{children && <div className="relative z-10 h-full">{children}</div>}
</div>
);
}
One prompt, any AI agent
Paste into Claude Code, Codex, Cursor or Windsurf. It carries your tweaks and the full source, so the agent installs it exactly.
Props
12 propsinnerstringColour of the streams nearest the void.default "#f3c9cf"default "#f3c9cf"outerstringColour of the streams further out.default "#4f73c9"default "#4f73c9"backgroundstringBackground colour.default "#000000"default "#000000"sizenumberSize of the void.default 1default 1densitynumberHow many streams.default 1default 1intensitynumberBrightness.default 1default 1glownumberStrength of the bloom.default 0.8default 0.8speednumberSpeed of the flow.default 1default 1interactivebooleanCursor lens, click ripple.default truedefault truescrollerElement | nullScroll container, if the page does not scroll the window.childrenReactNodeForeground content, drawn above the streams.classNamestringSize it, e.g. h-screen w-full.