CALIBRATED DEVICES. SHARED TIME. ONE CANVAS.
pixelmesh turns a room full of phones into a single synchronised display. Audiences open a URL, hold up their screens, and become pixels in a room-sized canvas. Light moves through the crowd as if it were one piece of hardware.
Every phone gets a shared clock and a known position. A camera at the front of the room watches the audience and reads an optical pattern blinking on each screen, mapping the entire crowd into a coordinate grid in about thirteen seconds. From there, a controller broadcasts effects and each device renders its own frame locally. A distributed shader running across a room.
The point isn't graphics on a crowd. It's coordination made visible. Distributed systems run beneath everything we use, almost always invisibly. pixelmesh pulls one into the open and lets a room watch it behave.
The hardest problem in the system is identification. pixelmesh solves it optically: each device blinks its screen on and off in a precise temporal pattern, while a single camera at the front of the room watches the entire crowd at once.
Each blink encodes a unique identifier in Manchester binary, a self-clocking format where every bit carries a guaranteed transition. A device tilted into shadow, held at an angle, or partially obscured still resolves cleanly, because the change is what gets read, not the absolute brightness.
A short, deliberately-illegal sync preamble at the start of every cycle lets the detector lock onto frame boundaries with no ambiguity. In about thirteen seconds, every device in the room is mapped to a coordinate.
No installs. No scans. No per-device setup. Open a URL, hold up the screen.
Each device calibrates its position into a shared coordinate grid. A central controller broadcasts effect parameters rather than pixel data, and every device computes its own output against a shared clock, a distributed shader running across the room. Low bandwidth, deterministic behaviour, and a crowd that becomes a single rendering engine.
The first public version used printed AprilTag markers for calibration. The current implementation replaces them with optically-encoded screen blinks, so audiences only need to open a URL. It ran live at PHP Stoke in February 2026, then again in Manchester three months later. Real audiences, real venues, lighting nothing like the controlled conditions it was built in.
What makes it land at an event is that the audience isn't watching the show. They are it. A few hundred phones snap into a single surface; light moves through the room as if it were one piece of hardware. No app, no install, no setup. Just a URL, then a moment that feels closer to physics than software.
Hosting a conference, meetup, or event? I'd love to bring pixelmesh to your venue.
Book pixelmeshpixelmesh stands on earlier explorations of independent screens forming a coherent visual surface, blending distributed systems engineering with projection mapping and real-time computation. Infrastructure behaving like art.
An early experiment in stitching mismatched, unmodified screens into a single synchronised display via a server-driven calibration pattern.
Audience phones turned into a coordinated light source, demonstrating how ordinary devices can act as a distributed performance instrument.
pixelmesh exists because coordination is invisible.
By day I lead engineering teams building systems that work at scale, under pressure, and in the real world. The work spans architecture, delivery, and people. Much of it is reducing developer friction: simplifying systems, tightening feedback loops, making it easier for teams to ship without losing control.
Distributed systems run beneath everything we use, yet we rarely see them behave as one. I wanted to find out what happens when infrastructure becomes visible: when independent devices share time, share space, and render as a single surface.
This is not a product demo. It is an experiment in synchronisation, scale, and emergent behaviour, built solo and tested in front of real audiences.