u/tsevis

I’ve been making mosaics since the late ’80s. These are twelve versions of the same portrait, made with different matching methods in my software. Some hold the face together better from a distance; others let more of the small patterned pieces come through.
Working on this sent me back through the research, from Bell Labs in 1966 to recent methods. I put what I found into a history of photographic mosaic algorithms, with a few opinions of my own:
https://www.tsevis.com/blog/history-of-mosaic-algorithms
Which version works best for you, and at what distance?

I have always liked faces as raw material.

Not portraits.
Faces as geometry.

Prosopon is a small macOS experiment built with Claude Code.

It aligns hundreds of portraits onto exactly the same facial grid using Apple Vision or InsightFace, then cuts them into quadrants and recombines four different people into one face.

The difficult part is not the cutting. It is making the seams disappear.

So Prosopon compares skin along the seams in linear light and CIE Lab, matches the mouth first, then improves the result with a small optimization pass.

A little computer vision.
A little geometry.
A little optimization.

Built in Swift over a few days.

And one lesson from Claude Code: plausible answers are cheap. Measuring them is much more useful.

Open source, MIT:
https://github.com/tsevis/prosopon

I love Adobe Bridge. It's my favorite file browser. But it can't sort images by color — so I built an extension that does.

BridgeColorShorter reads every image's actual palette (not just one dominant pixel), groups your files by color family, and ramps each group dark → light. Reds with reds. Golds with golds. 1,559 images, ~5 seconds.
Free. MIT-licensed. Runs right inside Bridge.

Heron is a small engine I built. You give it a photo. It gives back an image that looks captured by an instrument beyond human vision. Thermal camera. X-ray fluoroscope. Kirlian plate. Schlieren bench.

It is not a filter. A filter paints new colors on top of a photo. Heron does the opposite. It estimates what things are (skin, hair, fabric, metal, water, foliage), deletes the photograph's original lighting, then rebuilds the image from the material, not the light. A photo encodes external illumination. A thermogram encodes internal emission. That is the one rule everything else follows.

The part I think this sub will like is the architecture, not just the pictures.

Four layers, shared by every instrument:

• Scene understanding — depth, normals, material segmentation, de-lighting. Cached once per image as a "Radiance Graph," so every downstream layer reads from the same understanding of the scene.
• Physics — a different simulation per instrument. Emission for thermograph, Beer-Lambert attenuation for fluoroscope, Poisson photon noise for the intensifier tube, dielectric-breakdown streamers for Kirlian, a signed directional derivative of the thermal field for Schlieren.
• Sensor and optics — bloom, fixed-pattern noise, AGC, phosphor response, all seeded and deterministic. FPN is generated once per session, never re-rolled per frame, the way a real sensor's fixed pattern actually behaves.
• Art direction — saliency-driven emphasis, directional bloom, Poisson detail fusion.

Every instrument is a config of these four layers, not a separate codebase. Eight instruments right now, sixteen palette ramps interpolated in Oklab so lightness always climbs monotonically.

Same seed, same parameters, same output, every time. No cloud calls at render time, all model loading is local-files-only.

I am calling this an experiment in "system mosaics." Not one output, a system that produces outputs, assembled from small deterministic parts (a depth model, a material tagger, a physics sim, a palette engine) the way a mosaic is assembled from tesserae. No single part is the picture. The rules are.

MIT licensed, runs offline on a Mac: github.com/tsevis/heron