Entity Devlog #1: Nobody Should Have to Change Their Computer

Here's something you may not have noticed when you landed on this site: the thing behind the words is alive.

I call it Entity. It's a field of 48,000 particles, and (depending on your machine) every single particle is a light. It drifts, it gathers, it pulls toward things and lets them go, and it sits behind every page here, including this one. What Entity means to me is a whole other story, and I've already told that one in I've Never Found the Edge of It.

This is the other half: what it took to build, and the battle I'm still fighting just to make it run on your computer.

Pasted in, or living inside

It didn't start as particles. The first version of this site had a nested set of dodecahedrons floating behind everything, mostly because I thought it was an interesting shape to look at. The plan was to grow it into something more organic, a Voronoi-holed sphere with a cellular, sculptural surface. Then (for reasons explained in that other essay) I had the idea for the particles, and I dropped the sphere and went that way instead.

Entity lives inside a chamber, and from the start I wanted you to understand it really lived in there. That turned out to be the hard part. Without real lighting, every particle throwing light onto everything around it, it never looked right. It looked pasted in, like a sticker on the glass, instead of something living inside the room. I tried every lighting solution I could think of, and it still just didn't read right. That's why it runs on WebGPU, the newest way for a browser to talk to your graphics card.

So, the short version of why I chose particle-based lighting is "beauty." I wanted a thing that looked like it belonged where it was sitting.

And that's where the trouble starts. Forty-eight thousand lights is a lot to ask of a computer (even with cutting-edge TSL techniques), and I'm the madman asking it of every computer that visits.

The advice I refused

My own laptop is a gaming laptop, and Entity ran badly on it. Low frame rate, visible stutter, the works. So I asked the AI I build with to help me figure out why, and it kept coming back with the same kind of answer: change your settings. Switch Windows to high-performance graphics. Tell Chrome to use the better card.

Here's the thing. That advice was one technically correct option, but it was a complete non-starter.

Nobody visiting this site for the first time is going to know their computer needs some ridiculous performance setting flipped before the page looks right. They're not going to go digging through Windows menus because my background stuttered.

They would think the site is broken, and they'd be right.

It's like inviting someone over to my house for dinner and asking them to get their car detailed first. It makes no sense.

My job as someone who makes things is to meet my audience where they are. In the case of web experiences, I accommodate the choices they've made about their own machine, not demand that they accommodate mine.

Nobody should have to change their computer to have a good experience here.

As often happens with emerging tools, I had to teach the AI something about how to do this work.

Learning to read the room

The reason my laptop struggled is a good example of why this is hard. A lot of laptops have two graphics chips: a powerful one, and a weaker one that sips battery. Chrome on Windows runs on the weak one by default, and a website can't ask for the strong one. The request exists, but Chrome on Windows ignores it. So a very capable machine shows up looking like a modest one, and there's nothing the site can do to change that.

What the site can do is pay attention.

When you arrive, Entity spends its first moments measuring how hard your graphics chip is working to draw it. If it's straining, it steps itself down: fewer particles drawn, less lighting detail, a gentler frame rate.

It keeps stepping until it fits the machine it's actually on.

Then, it remembers that answer for a month, so the next time you visit it starts at the right level instead of making you sit through the test again. Before that work, a laptop with basic integrated graphics was being handed the exact same load as a high-end desktop. No wonder it choked.

Equally important is the fact that some visitors don't have WebGPU at all, depending on their browser and device — and I wanted to ensure they still got to meet Entity. Because of this, I built a second version on WebGL, the older and more widely supported way of doing 3D in a browser.

Yes, it gives up some of the beauty, most noticeably the per-particle lighting, but it keeps the experience essentially intact.

That mattered a lot to me. I want to share this with as many people as I can, and a version that runs everywhere beats a perfect one that only a few people can ever see, even if it requires some compromise on the part of my "big vision."

What I'm holding back

Even on high-end machines, there's a piece of Entity you can't see yet. I designed a glass shell to wrap around it, two overlapping layers with gaps that open and close as you get near. It's part of what Entity is supposed to be. It's also another (significant) performance tax, and I decided not to pay it yet.

I needed a workable baseline before I made the vision more complicated. If Entity can't run well on its own, wrapping it in reactive glass only makes the problem harder to see. So the shell waits. The Voronoi sphere I set aside at the beginning might come back someday too, depending on where the performance lands.

I haven't decided yet, because I'm not done with the performance.

The part I couldn't do alone

One thing did ship that I'm proud of. If you look at the bottom right of the home page, you'll find a switch between two states. The default is Churn, the busy, scattered waking mind. Switch it to Flow, and the whole cloud gathers into one shape: an egg-shaped loop around a bright point, modeled on Itzhak Bentov's idea of a toroidal universe, echoed by Robert Monroe's REBAL concept.

That one wasn't really mine to build. The split on most of this project is the same as the rest of my most recent work: the design and the architecture are mine, and the AI writes the code as I direct it to.

Flow was different.

I'll be the first to say that I don't understand the math or the physics of making something like that toroidal flow happen, so I leaned on the AI a lot. Even it struggled, over several weeks, to get the shape, the movement and the flow to look like Bentov's model.

The VR version, where you stand inside the core and look out, is prototyped on my local machine, but doesn't exist where you can experience it yourself, yet.