Genvissss

A browser-based generative visual studio, built in a single file. No install. No build step. Open and create.

This is not a product announcement or a technical manual. It's a working note about why I built it, what it does, and what I keep thinking about when I look at it running in a tab. Read it as a snapshot, not a prescription. Take what resonates, leave what doesn't.

What it is

Genvissss is a browser-based generative visual studio. Drop in an image or a video, pick a scene, dial the parameters, export.

Eleven scenes. Twenty-four palettes. Seeded randomness so every render is reproducible. PNG, JPG, and WebM export. No server. No build step. A single file you open directly.

Repo: GitHub Repository

The scenes

Each scene is a different way of looking at the same source material:

• Recolor: hue-shift or gradient-map the source in real time
• Dither: Bayer matrix or Floyd-Steinberg dithering with palette tinting
• Halftone: rotatable dot, square, or line halftone screen
• ASCII: character-mapped rendering: blocks, ASCII, binary, dots
• Glitch: RGB split, scan-line noise, pixel slice corruption
• Tone: tonal shape rendering using line, circle, cross, triangle
• Mosaic: pixelated mosaic with colour quantisation and rounded tiles
• Binary: high-contrast binary pattern overlay
• Track: motion region detection and connection graph
• CCTV: multi-camera surveillance grid with scan-line noise
• Dissolve: Spectral Atomization, the image dissolved into a chromatic dot field

They're not filters. They're lenses. Each one encodes a different theory of what an image is and how it should be processed.

Why everything starts alive

One decision I'm glad I made: a universal demo image renders in every scene before you upload anything.

A vivid, coloured blob canvas. Generic enough to show the algorithm clearly. Alive enough that the sliders feel meaningful from the first interaction.

Most creative tools start empty and wait for you to bring material. That's a wall. Genvissss starts running. You walk into something already in motion.

Spectral Atomization

The Dissolve scene is the one I keep thinking about.

The philosophy behind it is this: no image is truly continuous. It is a convenient lie. Reality is granular. Spectral Atomization makes that truth visible.

Every pixel in the source image becomes a potential dot. A seeded random grid of sample points is laid over the canvas. Each point is jittered by grain. Each dot is sized by the saturation and luminance of the colour it samples. A glow pass blurs oversized halos behind the dots. Sparkle particles scatter specular light across the composition like stardust caught in light.

Two realities coexist in the output: the sharp dot field itself, and the soft chromatic ghost of the original image blurred beneath them. A luminous memory that the dots both reveal and obscure.

The cumulative effect reconstructs the original not through continuous tone but through discrete presence.

The Grain parameter is the most interesting control. At low values, the mathematical grid asserts itself with quiet authority. At high values, the composition breathes and dissolves, the image's subject becoming a suggestion rather than a declaration.

And then there's seed. Every seed value produces a unique crystallization of the stardust field. An arrangement that feels inevitable rather than designed.

Parameters

The Dissolve scene has six:

Every other scene also has six sliders, tuned to its own algorithm. The constraint is intentional. Six is enough to feel like a system. Not so many that you're managing a dashboard.

Quick start

git clone https://github.com/A043-studios/Genvissss.git
cd Genvissss
open genvissss.html

Or just double-click the file. No server required.

The live version is at a043.xyz/genvissss.

Why one file

genvissss.html is self-contained. Vanilla JS, Canvas 2D, no frameworks, no bundler, no CDN dependencies.

I could have built this differently. Reached for a framework. Added a bundler. Split everything into components and modules.

But that would've meant inheriting assumptions I didn't want: about how state gets managed, how things get loaded, what the development loop looks like, how you share or deploy it.

A single HTML file has a different quality. You can read it. You can open it anywhere. You can fork it without a setup ritual. You can understand the whole thing in one sitting.

Ownable. Not just usable.

There are two other artefacts alongside the main studio:

• dot-dissolve.html is a standalone version of the Dissolve engine with its own dark floating panel and SVG export. Open it in any browser.
• src/DotDissolver.tsx is a drop-in React component for Next.js and React 18+. No additional dependencies beyond React itself.

Three delivery formats, same engine. Pick whichever fits where you're working.

Seeded randomness

One of the quieter decisions in Genvissss: everything random is seeded.

The PRNG is mulberry32, fast, deterministic, reproducible across browsers. Hit Randomize and you get a new seed. Note the seed, come back later, and you get exactly the same render.

This matters more than it sounds. Generative work can feel ungovernable. You get something you love and you can't get back to it. Seeded randomness makes the system repeatable. You can share a seed number instead of a file.

MIT

Same as everything else I put out. Take it. Fork it. Break it. Ship something unrecognizable.

Closing thought

The thing that still surprises me: watching the Dissolve scene run on a portrait photograph.

The face doesn't disappear. It becomes a field of coloured spheres that still reads as a face. The algorithm strips the continuous lie and shows you the granular truth, and the recognition survives.

That is the interesting part. Not the dots. The fact that meaning persists through dissolution.