FLUID / DEVELOPERS
Make room for movement.
Fluid brings 58 procedural looks together in eight collections. Explore the collection, shape a piece in the integrated studio, or draw it directly inside your own page with the bundled Fluid Core 3.3.0 library.
Try website backgrounds View the catalogue
Building an interface? Explore Fluid’s creative toolkit: 39 React components, generators, complete sections and experiments, with live previews, portable CSS, complete source bundles and local exports.
01 / QUICK START
A living background. A few lines.
Serve this site over HTTP and import the bundled native module. Give the container a size, choose a named look, and set a seed to keep its composition consistent. The library creates its canvas and manages animation and resizing.
<div id="background" style="width:100%;height:60vh"></div>
<script type="module">
import { createFluid } from './vendor/fluid-core/src/index.js';
const art = createFluid(document.querySelector('#background'), {
look: 'MONSOON',
seed: 42
});
// In a component, call art.destroy() when it unmounts.
window.addEventListener('pagehide', (event) => {
if (!event.persisted) art.destroy();
});
</script>
Keep the whole vendor/fluid-core folder when copying the library into another project; its entry point imports sibling modules. No package installation or API key is needed. WebGL is required, so provide a static fallback if initialization fails.
02 / NATIVE API
Start with a look. Make it yours.
createFluid(element, options)- Mount a procedural canvas. Choose
lookandseed, or use field, palette, layer, material, substrate, and lens options. art.set(options)- Update a piece in place. Selecting a new look resets its previous layers and material settings; include overrides in the same call.
art.pause()/art.play()- Control playback. The library also respects reduced motion by default and pauses when offscreen or in a hidden tab.
art.toDataURL()- Render a still and return a PNG data URL.
art.shareUrl('./studio.html')- Build a link to open the current procedural settings in this site's studio.
art.destroy()- Stop animation, disconnect observers, and remove the canvas when it is no longer needed.
The bundled version includes all 58 looks and 30 field engines. The shared catalogue groups those looks into Living gradients, Fluid forms, Liquid metal, Print & pixels, Patterns & rhythm, Impossible spaces, Paint & paper, and Surfaces & street. See the library guide and TypeScript definitions for the full option surface.
Fluid Core draws procedural artwork. Image melt, text and logo masks, cursor effects, and recording belong to the studio.
03 / STUDIO OUTPUT
From a live canvas to a finished piece.
The integrated studio includes PNG, JPG, and WebP still exports, share links, and embed options. Live clip recording uses MP4 or WebM according to browser support; offline MP4 export requires supported WebCodecs and is unavailable on iOS. Export resolution and performance depend on the browser and device.
Studio saved designs retain settings and a thumbnail, but do not retain the original photo. Share links carry settings, and standalone HTML exports reproduce procedural artwork; they do not include uploaded photos or text and logo masks. Keep the original source files when working with images.
04 / PHOTO → FIRE
An image, a canvas, a render loop.
The separate Photo → Fire renderer turns a local image into animated fire with WebGL. Save engine.js beside an HTML file containing this example and serve the folder over HTTP. Choose an image to start; no build step, account, or API key is needed.
Download engine.js Open the photo editor
<input id="photo" type="file" accept="image/*">
<canvas id="fire" style="width:100%;height:60vh"></canvas>
<script type="module">
import { FireRenderer } from './engine.js';
const canvas = document.querySelector('#fire');
const renderer = new FireRenderer(canvas);
let ready = false;
let frame;
renderer.setOptions({
intensity: 0.7, heat: 0.7, motion: 0.5, detail: 0.5,
color: 'ember', region: 'edges', paused: false
});
const resize = new ResizeObserver(() => {
const dpr = Math.min(window.devicePixelRatio || 1, 2);
renderer.resize(
Math.max(1, Math.round(canvas.clientWidth * dpr)),
Math.max(1, Math.round(canvas.clientHeight * dpr))
);
});
resize.observe(canvas);
document.querySelector('#photo').addEventListener('change', async (event) => {
const file = event.target.files[0];
if (!file) return;
const url = URL.createObjectURL(file);
const image = new Image();
try {
image.src = url;
await image.decode();
await renderer.setSource(image);
ready = true;
} catch (error) {
console.error('Could not open this image.', error);
} finally {
URL.revokeObjectURL(url);
}
});
function animate(milliseconds) {
if (ready) renderer.render(milliseconds / 1000);
frame = requestAnimationFrame(animate);
}
frame = requestAnimationFrame(animate);
// Call when your app removes the canvas.
function cleanup() {
cancelAnimationFrame(frame);
resize.disconnect();
renderer.destroy();
}
</script>
render() expects seconds. The renderer does not start its own animation loop; keep calling it while the canvas is visible. Handle renderer initialization errors if WebGL is unavailable on the user's device.
05 / FIRE API
Small surface. Room to experiment.
new FireRenderer(canvas)- Create a renderer for an HTML canvas.
setSource(imageElement)- Use a decoded
HTMLImageElementas the source. Images from another origin need suitable CORS permission; local uploads avoid that requirement. setOptions(options)- Set
intensity,heat,motion, anddetail. Choosecolor: 'ember' | 'inferno' | 'blue'andregion: 'edges' | 'all'. Setpausedto a boolean. render(timeSeconds)- Draw one frame at the supplied time.
resize(width, height)- Set the drawing dimensions in pixels when your canvas changes size.
destroy()- Release renderer resources after stopping your animation loop.
06 / PHOTO PROJECTS
Create locally. Keep the result.
The photo editor provides image upload, fire controls, before/after comparison, and pause. Save a PNG still, record a WebM clip when your browser supports it, or download an editable .fluid.json project containing the image and effect settings.
Image processing happens on your device. The editor does not upload your selected image, and no sign-in is needed. A project file includes the image itself, so sharing that file also shares its image.
These image-inclusive projects belong to Photo → Fire and use a different format from the studio's saved designs. PNG, clip, and project exports belong to the photo editor; FireRenderer supplies the canvas effect and does not provide file management.
07 / MCP
Know which catalogue you're using.
The existing production MCP endpoint at befluid.xyz/mcp serves 42 procedural looks. It may not expose the additional Fluid 3.3 looks and material controls available in this site's 58-look catalogue and bundled native library.
That endpoint does not accept photo uploads or expose Photo → Fire. This site does not update the production endpoint, publish a local MCP server, or add photo-specific MCP tools. Use the native module for procedural backgrounds and engine.js for photo effects.
08 / IMAGE DITHERING
A different kind of texture.
Open the dither generator to convert a local image into two colours. Try ordered 4×4 or 8×8 patterns, Floyd–Steinberg, Atkinson, or a clean threshold. Tune pixel size, brightness, contrast, ink and paper, then export a PNG.
The dependency-free dither-core.js module also works on its own. It takes an RGBA byte buffer and returns a new one. Dark tones become foreground ink; light tones become background paper. The source buffer is unchanged and alpha is preserved.
import { ditherImage } from './dither-core.js';
const source = context.getImageData(0, 0, width, height);
const result = ditherImage(source, {
algorithm: 'floyd',
foreground: '#18191b',
background: '#f1efeb',
brightness: 0,
contrast: 0,
threshold: 128,
invert: false
});
context.putImageData(new ImageData(
result.data, result.width, result.height
), 0, 0);
Algorithm names are ordered4, ordered8, floyd, atkinson and threshold. Brightness and contrast range from −100 to 100; threshold ranges from 0 to 255. The generator runs processing in a worker, limits uploads to 25 MB / 40 megapixels, and caps export at 2048 pixels on the longest edge. Pixel-size resampling belongs to the editor, rather than the core function. No image is uploaded to a server.